Mots-clé : langage de programmation

Go langage

Mémo go

Uniquement des notes sur ce qui est « original » dans le langage « go », par rapport aux autres langages.

Variables

Déclaration

Par rapport à tous les autres langages, il faut le faire à l’envers :
var x int
Et pour un tableau : var [nom] [[longueur]][type], exemple :
var s [3]int

Initialisation avec des valeurs

Pas d’explication, un exemple direct suffit : arr := [2]int{2, 4}

Inférence de type

Une déclaration complète d’une variable serait var i int = 12
Une déclaration ultra simplifiée acceptable est i := 12 et dans ce cas, Go va tenter de deviner le type (« type inference »).

Comparaison de tableaux

La déclaration de variables se fait toujours en précisant la longueur, et au moment de comparer, il faut que les tableaux aient exactement la même longueur, sinon on aura une erreur. C’est pour cela que les tableaux sont moins utilisés que le type slice.

Comparaison = avoir des types identiques

Go n’essaie jamais de transformer les variables en booléens pour pouvoir les comparer, c’est à nous transformer une variable ou l’autre de manière à ce qu’elles aient toujours le même type.

Création d’une variable dans un « if »

Exemple direct : if b:= a / 2; b > 5 {...} else {...}
La variable b n’existera que dans le bloc if / else.

Boucle for / range

s := "Bonjour"
for k, v := range s {
    fmt.Println(k, v, string(v))
}

k correspond à l’index, et n’est pas toujours incrémenté que de 1, selon l’encodage. C’est la méthode à utiliser pour parcourir une chaîne en utf8. Car via un classique for, Go parcourra la chaîne « à la » C, c’est à dire que un caractère = un octet (ce qui n’est pas le cas en utf8).

Switch / case

Par défaut, les « break » sont implicites, pas besoin de les mettre. Si on veut exécuter l’instruction du « case » suivant (= comme en C ou JavaScript), il faut le dire explicitement via « fallthrough« .

Il est possible de créer une variable qui ne vivra que le temps du switch / case, exemple :

switch l := len(word); word {
    ...blabla...
}

Contrairement aux autres langages, il ne faut pas mettre plusieurs case d’affilée pour gérer plusieurs cas au même endroit, il suffit de les séparer par une virgule, exemple pour continuer le précédent :

switch l := len(word); word {
case 1 < l && l < 10, word == "ok":
    fmt.Println("Soit mot : 1 < longueur < 10, soit il vaut 'ok'")
}

Fonctions

Appels

Tous les appels de fonction sont par valeur. Jamais par référence. Nombre, booléen, ainsi que les tableaux.

Fonctions en tant que variable

Exemple direct :
func myFunc() {
    f := func(a int) int {
        return a + 1
    }
    fmt.Println(f(1))
}

Fonctions en tant que paramètres

Exemple direct d’un paramètre qui doit être « une fonction qui prend un entier en tant que paramètre et renvoie un entier » :
func myFunc(a int, f func(int) int) {
    fmt.Println(f(a))
}

Pointeurs

Appels

Conversions

Astuces classiques

Site officiel

Packages

Funciton : un langage lisible et marrant

Voici, pour ceux qui ne le connaissent pas, un langage très récent (2011), fonctionnel, et lisible, mais entièrement nouveau, j’ai nommé (roulement de tambours) : « Funciton »

Voici un exemple de programme qui fonctionne, essayez de deviner ce qu’il fait :

(Note : ce n’est pas un dessin, c’est bien du texte, vous pouvez le sélectionner et le copier coller, ça fonctionne, essayez !) :


            ╓───╖
         ┌──╢ + ╟──┐
         │  ╙───╜  │
    ┌────┴────┬────┴────┐
    │  ┌┐     │      ┌┐ │
  ┌─┴──┤├──whoops!─┬─┤├─┴─┐
  │    └┘     │    │ └┘   │  ╔════════════════════════════╗
  │    ┌──────┴───┬┘      │  ║  addition — WITH           ║
  │   ┌┴┐        ┌┴┐      │  ║  THREE PROBLEMS (read on)  ║
  │   └┬┘        └┬┘      │  ╟────────────────────────────╢
  │ ┌──┴─╖  ┌───╖ │       │  ║  +(a, b) = b               ║
  │ │ << ╟──┤ + ╟─┘       │  ║      ? +(a^b, (a&b) << 1)  ║   │ ╘══╤═╝  ╘═╤═╝         │  ║      : a                   ║   │  ╔═╧═╗    │           │  ╚════════════════════════════╝   │  ║ 1 ║    │           │   │  ╚═══╝  ┌─┴─╖         │   └─────────┤ ? ╟─────────┘             ╘═╤═╝               │

Vous pouvez avoir toutes les informations sur Wikipedia ici :

http://esolangs.org/wiki/Funciton

Python : mes premiers essais

Bon, sur cet article ici, j’ai traduit tout le vécu d’un auteur, et j’ai voulu tester par moi même.

En pratique, j’ai installé un dictionnaire de Français entièrement gratuit, et je voulais récupérer les mots Français, sans la définition (je ne dirai pas pourquoi par contre hahahah).

Donc je regarde les fichiers, c’est du XML.
Ok donc il me faut juste un parseur.
En Delphi, ça m’aurait pris disons… une trentaine de minutes.
Eh bien pour mon premier script en Python, ça m’a pris… 10 minutes.
Oui oui je n’exagère pas : 10 minutes, j’ai lancé le chrono pour voir si j’allais être rapide ou pas.
Voilà mon script :

1 #! /usr/bin/env python
2 # -*- coding: utf-8 -*-
3
4 # r = open('/datas/dictionnaire/test
5
6 import types, fileinput
7
8 def process(line):
9 if line[0:7] == ' 0):
12 sub = sub[:sub.find(' ')]
13 if (sub.find(',') > 0):
14 sub = sub[:sub.find(',')]
15 print(sub)
16
17 for line in fileinput.input():
18 process(line)

Incroyable. Effectivement, en pratique c’est vraiment ce que j’ai mis sur mon article précédent : tout est clair, lisible, la documentation aide bien, et c’est extrêmement rapide, en tous les cas sa rapidité suffit amplement pour faire toutes les tâches de scripts de base que l’on veut.

Je suis extrêmement content, à part depuis la découverte de la librairie ExtJs, qui est très impressionnante, ça allait faire longtemps que je n’avais pas été autant enthousiasmé (du point de vue informatique, j’entends).