Python和JavaScript 2020年你認為那個走的更遠

本篇文章為大家展示了Python和JavaScript 2020年你認為那個走的更遠，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

Python 和 JavaScript 是目前最火的兩大編程語言，但是 2020 年，什么編程語言將會取而代之呢?

以下為譯文：

Python 和 JavaScript  是目前最火的兩大編程語言。然而，他們不可能永遠屹立不倒。最終，必將像其他編程語言一樣跌下神壇。這很可能在接下來的十年左右上演。

那么什么編程語言將會取而代之呢? 下面給出我的候選者名單!

Dart

多虧了 Flutter 框架和 Google 的認可，該語言迅速流行開來。這和 Rails 框架讓 Ruby 流行起來的原因非常相似。如果谷歌的  Fuchsia 系統能夠火起來，Dart 將受益最大。

• 核心優勢：它是一種比 JavaScript 更棒的編程語言。

• 主要缺點：不得不面對 JavaScript 語言和 JavaScript 的強烈擁護者的挑戰。

曼德布洛特集樣本：

class Complex {  double _r,_i;   Complex(this._r,this._i);  double  get r => _r;  double get i => _i;  String toString() => "($r,$i)";    Complex operator +(Complex other) => new  Complex(r+other.r,i+other.i);  Complex operator *(Complex other) =>       new Complex(r*other.r-i*other.i,r*other.i+other.r*i);  double  abs() => r*r+i*i;} void main() {  double start_x=-1.5;  double  start_y=-1.0;  double step_x=0.03;  double step_y=0.1;   for(int y=0; y<20;y++) {    String line="";    for(int x=0;x<70;x++) {       Complex c=new Complex(start_x+step_x*x,start_y+step_y*y);       Complex z=new Complex(0.0, 0.0);      for(int i=0;i<100;i++) {         z=z*(z)+c;        if(z.abs()>2) {          break;        }       }      line+=z.abs()>2 ? " " : "*";    }    print(line);  }}

Elixir

Elixir 是基于一種基于 Erlang 虛擬機的函數式編程語言，對并發的支持非常好。作為一個純粹的函數式編程語言，它有望將這種范式變為主流。

• 核心優勢：它讓函數式編程變得異常簡單，對并發的支持非常棒。

• 主要缺點：需要有 OTP 基礎，但掌握 OTP 卻沒那么容易。

曼德布洛特集樣本：

defmodule Mandelbrot do  def set do    xsize = 59    ysize = 21     minIm = -1.0    maxIm = 1.0    minRe = -2.0    maxRe = 1.0    stepX  = (maxRe - minRe) / xsize    stepY = (maxIm - minIm) / ysize     Enum.each(0..ysize, fn y ->      im = minIm + stepY * y       Enum.map(0..xsize, fn x ->        re = minRe + stepX * x        62 -  loop(0, re, im, re, im, re*re+im*im)      end) |> IO.puts    end)   end   defp loop(n, _, _, _, _, _) when n>=30, do: n  defp loop(n,  _, _, _, _, v) when v>4.0, do: n-1  defp loop(n, re, im, zr, zi, _)  do    a = zr * zr    b = zi * zi    loop(n+1, re, im, a-b+re,  2*zr*zi+im, a+b)  endend Mandelbrot.set

Golang

得益于其閃電般的編譯速度、簡單和高效的并發支持，另外一個谷歌受支持的編程語言 Golang  已經嶄露頭角。唯一缺的就是泛型支持，但是這個特性已經在規劃上了。

• 核心優勢：上手簡單，對并發的支持非常出色。

• 主要缺點：缺少泛型支持(暫時的)。

曼德布洛特集樣本：

package main import (    "fmt"    "image"    "image/color"     "image/draw"    "image/png"    "math/cmplx"    "os") const (     maxEsc = 100    rMin   = -2.    rMax   = .5    iMin   = -1.     iMax   = 1.    width  = 750    red    = 230    green  = 235     blue   = 255) func mandelbrot(a complex128) float64 {    i := 0     for z := a; cmplx.Abs(z) < 2 && i < maxEsc; i++ {        z = z*z  + a    }    return float64(maxEsc-i) / maxEsc} func main() {     scale := width / (rMax - rMin)    height := int(scale * (iMax -  iMin))    bounds := image.Rect(0, 0, width, height)    b :=  image.NewNRGBA(bounds)    draw.Draw(b, bounds,  image.NewUniform(color.Black), image.ZP, draw.Src)    for x := 0;  x < width; x++ {        for y := 0; y < height; y++ {             fEsc := mandelbrot(complex(                float64(x)/scale+rMin,                float64(y)/scale+iMin))             b.Set(x, y, color.NRGBA{uint8(red * fEsc),                 uint8(green * fEsc), uint8(blue * fEsc), 255})          }    }    f, err := os.Create("mandelbrot.png")     if err != nil {        fmt.Println(err)         return    }    if err = png.Encode(f, b); err != nil {         fmt.Println(err)    }     if err = f.Close(); err != nil {         fmt.Println(err)    }}

Julia

Julia 的優勢在于對數學計算的支持非常出色。它對數學的語法支持非常好，堪稱數據科學家的福音。假如有任何編程語言可以顛覆 Python,  它將是一個強有力的競爭者。

• 核心優勢：為科學家精心設計。

• 主要缺點：面臨著數據科學之王 Python 的競爭。

曼德布洛特集樣本：

using Images @inline function hsv2rgb(h, s, v)    const c = v * s     const x = c * (1 - abs(((h/60) % 2) - 1))    const m = v - c      const r,g,b =        if h < 60            (c, x, 0)         elseif h < 120            (x, c, 0)        elseif h < 180      (0, c, x)        elseif h < 240            (0, x, c)        elseif h < 300            (x, 0, c)        else            (c, 0,  x)        end     (r + m), (b + m), (g + m)end function mandelbrot()     const w, h = 1000, 1000     const zoom  = 0.5     const moveX = 0    const moveY = 0     const img =  Array{RGB{Float64}}(h, w)    const maxIter = 30     for x in 1:w         for y in 1:h            i = maxIter            const c =  Complex(                (2*x - w) / (w * zoom) + moveX,                 (2*y - h) / (h * zoom) + moveY            )             z = c            while abs(z) < 2 && (i -= 1) > 0                 z = z^2 + c            end             const r,g,b = hsv2rgb(i / maxIter * 360, 1, i / maxIter)            img[y,x] = RGB{Float64}(r, g, b)         end    end     save("mandelbrot_set.png", img)end mandelbrot()

Kotlin

Kotlin 是升級版的 Java。 實際上，它可以完全替代 Java 編程語言，谷歌已經將其打造成 Android 開發的首選語言。

• 核心優勢：比 Java 更強大。

• 主要缺點：Kotlin 非常龐大，甚至比 Java 更龐大。

曼德布洛特集樣本：

import java.awt.Graphicsimport java.awt.image.BufferedImageimport javax.swing.JFrame class Mandelbrot: JFrame("Mandelbrot Set") {    companion object {        private const val MAX_ITER = 570        private const val ZOOM = 150.0    }      private val img: BufferedImage     init {        setBounds(100, 100, 800, 600)        isResizable = false        defaultCloseOperation = EXIT_ON_CLOSE        img = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)        for (y in 0 until height) {             for (x in 0 until width) {                 var zx = 0.0                var zy = 0.0                val cX = (x - 400) / ZOOM                val cY = (y - 300) / ZOOM                 var iter = MAX_ITER                while (zx * zx + zy * zy < 4.0 && iter > 0) {                    val tmp = zx * zx - zy * zy + cX                    zy = 2.0 * zx * zy + cY                    zx = tmp                    iter--                }                 img.setRGB(x, y, iter or (iter shl 7))            }        }    }      override fun paint(g: Graphics) {         g.drawImage(img, 0, 0, this)    }} fun main(args: Array<String>) {    Mandelbrot().isVisible = true}

Lua

• 核心優勢： Lua 是一種小巧、簡單、快速、可嵌入、可移植和靈活的編程語言。

• 主要缺點：Lua 被忽視了 26 年了。現在還能掀起風浪嗎?

曼德布洛特集樣本：

local maxIterations = 250local minX, maxX, minY, maxY = -2.5, 2.5, -2.5, 2.5local miX, mxX, miY, mxYfunction remap( x, t1, t2, s1, s2 )     local f = ( x - t1 ) / ( t2 - t1 )    local g = f * ( s2 - s1 ) + s1     return g;endfunction drawMandelbrot()    local pts, a, as, za, b, bs, zb, cnt, clr = {}    for j = 0, hei - 1 do         for i = 0, wid - 1 do             a = remap( i, 0, wid, minX, maxX )            b = remap( j, 0, hei, minY, maxY )            cnt = 0; za = a; zb = b            while( cnt < maxIterations ) do                 as = a * a - b * b; bs = 2 * a * b                 a = za + as; b = zb + bs                 if math.abs( a ) + math.abs( b ) > 16 then break end                cnt = cnt + 1             end            if cnt == maxIterations then clr = 0            else clr = remap( cnt, 0, maxIterations, 0, 255 )             end            pts[1] = { i, j, clr, clr, 0, 255 }            love.graphics.points( pts )         end    endendfunction startFractal()    love.graphics.setCanvas( canvas ); love.graphics.clear()     love.graphics.setColor( 255, 255, 255 )    drawMandelbrot(); love.graphics.setCanvas()endfunction love.load()     wid, hei = love.graphics.getWidth(), love.graphics.getHeight()    canvas = love.graphics.newCanvas( wid, hei )    startFractal()endfunction love.mousepressed( x, y, button, istouch )    if button ==  1 then         startDrag = true; miX = x; miY = y    else        minX = -2.5; maxX = 2.5; minY = minX; maxY = maxX         startFractal()        startDrag = false    endendfunction love.mousereleased( x, y, button, istouch )     if startDrag then        local l         if x > miX then mxX = x        else l = x; mxX = miX; miX = l        end        if y > miY then mxY = y         else l = y; mxY = miY; miY = l        end         miX = remap( miX, 0, wid, minX, maxX )          mxX = remap( mxX, 0, wid, minX, maxX )         miY = remap( miY, 0, hei, minY, maxY )          mxY = remap( mxY, 0, hei, minY, maxY )         minX = miX; maxX = mxX; minY = miY; maxY = mxY        startFractal()    endendfunction love.draw()    love.graphics.draw( canvas )end

Pharo

Pharo 是 Smalltalk 的現代版變體，是一個非常高效的面向對象編程語言。事實上，Smalltalk  是面向對象的典范，幾乎所有的其他面向對象編程語言都受到它的啟發。卻沒有一個編程語言比 Smalltalk 面向對象的程度更高。

Pharo 也是世界上最簡單、最優雅的編程語言之一，你只需要 15 分鐘就能掌握 Smalltalk 的全部語法。

• 關鍵優勢：開發效率非常高，編程效率能提升接近 5 倍。

• 主要缺點：它需要一種與眾不同的編程思維。但是人總是害怕改變，很難接受這種編程思維。

分形樹樣本：

Object subclass: #FractalTree    instanceVariableNames: ''    classVariableNames: ''    poolDictionaries: ''    category:  'RosettaCode'"Methods for FractalTree class"tree: aPoint length: aLength angle: anAngle    | p a |    (aLength > 10) ifTrue: [         p := Pen new.        p up.        p goto: aPoint.        p turn: anAngle.        p down.        5 timesRepeat: [            p go:  aLength / 5.            p turn: 5.        ].        a := anAngle -  30.        3 timesRepeat: [            self tree: p location length:  aLength * 0.7 angle: a.            a := a + 30.        ]    ].draw     Display restoreAfter: [        Display fillWhite.               self tree: 700@700 length: 200 angle: 0.    ]"Execute"FractalTree new draw.

Rust

由于內存安全特性——借用檢查器，Rust 已經贏得廣泛認可。這一特性實際上消除了所有內存相關錯誤。Rust 提供了更安全的編程特性。

• 關鍵優勢：有助于提高軟件的可靠性。

• 主要缺點：它學起來很難。借用檢查器比較復雜且難以理解。

曼德布洛特集樣本：

extern crate image;extern crate num_complex; use std::fs::File;use  num_complex::Complex; fn main() {    let max_iterations = 256u16;     let img_side = 800u32;    let cxmin = -2f32;    let cxmax = 1f32;    let cymin = -1.5f32;    let cymax = 1.5f32;    let scalex  = (cxmax - cxmin) / img_side as f32;    let scaley = (cymax - cymin) / img_side as f32;     // Create a new ImgBuf    let mut  imgbuf = image::ImageBuffer::new(img_side, img_side);     // Calculate for each pixel    for (x, y, pixel) in  imgbuf.enumerate_pixels_mut() {        let cx = cxmin + x as f32 *  scalex;        let cy = cymin + y as f32 * scaley;          let c = Complex::new(cx, cy);        let mut z = Complex::new(0f32, 0f32);         let mut i = 0;        for t in  0..max_iterations {            if z.norm() > 2.0 {                break;            }            z = z * z + c;            i = t;         }         *pixel = image::Luma([i as u8]);    }     // Save image    let fout = &mut File::create("fractal.png").unwrap();     image::ImageLuma8(imgbuf).save(fout, image::PNG).unwrap();}

TypeScript

TypeScript 是一個增強版的 JavaScript. 它主要新增了靜態類型的特性。

由于 TypeScript 和 JavaScript 完全兼容，已經掌握了 JavaScript 的前端 web 開發者們可以輕松掌握  TypeScript，因而深受他們青睞。

• 核心優勢：它是 JavaScript 的超集 , 對 JavaScript 開發者來說沒啥太大變化。

• 主要缺點：由于它是 JavaScript 的超級，這就導致了它同樣也繼承了 JavaScript 的一些歷史包袱。

分形樹樣本：

// Set up canvas for drawingvar canvas: HTMLCanvasElement =  document.createElement('canvas')canvas.width = 600canvas.height =  500document.body.appendChild(canvas)var ctx:  CanvasRenderingContext2D = canvas.getContext('2d')ctx.fillStyle =  '#000'ctx.lineWidth = 1 // constantsconst degToRad: number =  Math.PI / 180.0const totalDepth: number = 9 /** Helper function  that draws a line on the canvas */function drawLine(x1: number,  y1: number, x2: number, y2: number): void {    ctx.moveTo(x1, y1)     ctx.lineTo(x2, y2)} /** Draws a branch at the given point and  angle and then calls itself twice */function drawTree(x1: number,  y1: number, angle: number, depth: number): void {    if (depth !==  0) {        let x2: number = x1 + (Math.cos(angle * degToRad) *  depth * 10.0)        let y2: number = y1 + (Math.sin(angle *  degToRad) * depth * 10.0)        drawLine(x1, y1, x2, y2)         drawTree(x2, y2, angle - 20, depth - 1)        drawTree(x2,  y2, angle + 20, depth - 1)    }} // actual drawing of  treectx.beginPath()drawTree(300, 500, -90,  totalDepth)ctx.closePath()ctx.stroke()

WebAssembly

WebAssembly 是一匹黑馬。在接下來的十年左右的時間，它可能會衍生出一系列編程語言，這些編程語言有望登頂編程語言排行榜。

雖然 WebAssembly 只是一個編譯目標，但是它有充足理由被應用到 Web 領域之外。哪種基于 WebAssembly  的編程語言能夠榮登榜首?誰也說不準。

上述內容就是Python和JavaScript 2020年你認為那個走的更遠，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。