GO Chokisomemo 1

println

Si vous écrivez un caractère entre () de println (), le contenu de () sera affiché sur la console. println est l'une des "commandes" fournies par Go En bref, cela signifie sortir celui entre () 
pacage imo
func imo() {
     println("hello.monde")
}

Opérateur "Chaîne de caractères" "+" La chaîne doit être placée entre guillemets ("). Sinon, une erreur se produira. ("xx" + "xx") Concatène les chaînes en une seule chaîne. 
package imo
func imo(){
 println ("bonjour, bonne réponse")
 println ("bonjour" + "bonne réponse")
}

Comment rédiger un commentaire Il existe deux types: ** commentaire de bloc ** et ** commentaire de ligne **. Les commentaires de bloc sont des commentaires entre / * et * /, et les commentaires de ligne sont des commentaires de // (deux barres obliques) jusqu'à la fin de la ligne. 
package imo
func imo(){
  /*

 */

 println ("bonjour, monde")
 // println ("bonjour, monde")
}

Valeur numérique (un peu basique) Utilisez "*" pour la multiplication et "/" pour la division. De plus, "%" est une division, "+" addition, "-" soustraction. 
  panag imo
  func imo(){
      println(2)
      printlm(2 + 3)
      println(4 - 7)
}

Variable 1 #### "Type de données de nom de variable Var" #### Vous pouvez définir des variables en écrivant. De plus, var est une abréviation de variable, qui signifie variable en anglais. Si vous souhaitez mettre à jour les données, vous pouvez les mettre à jour avec la variable name = Ga-shomi, le type de données semble être omis (var a = 100) ######
type int [type de variable] Est l'un des types de variables (boîtes pour stocker des données en programmation) C'est comme une règle selon laquelle "vous pouvez mettre un entier (pas un grand nombre de chiffres) dans cette case"
Type de chaîne [Type de variable] </ dl>

Un des types de variables (boîtes pour stocker des données en programmation) C'est comme une règle selon laquelle "vous pouvez mettre une chaîne de caractères (une collection de caractères) dans cette case"

    pacage imo 
    func imo(){
         var n int
             n = 100
       println(n)
}

 pacage imo
    func imo (){
       var n int =100
   println(n)
}

Omission de type de données

Dans Go, lorsque la définition de variable et l'attribution de valeur sont effectuées en même temps, comme "var a int = 100" Spécification du type de données omise ok ** "var a = 100" ** et int omis ok

  package imo
  func main(){
    var a = 100
  
  println(a)
}

De plus, si vous écrivez quelque chose comme " b: = 200", cela a la même signification que "var b int = 200" </ font> = (égal) au lieu de: = (deux-points et égal). Cette façon d'écrire est correcte

  package imo
     func imo(){
              b:= 200 
  println(b)
}

package main
  func main() {
     a := 100
     b := 200
 prntcl(100,200)
}

Il semble qu'il est acceptable de l'omettre au plus haut

Fonctionnement variable ~~~ package imo func imo(){ n := 10 println(n + 20) } // Résultat: 30 ~~~

auto-affectation </ font>

package imo 
func imo(){
   n := 10
   n=n + 20
 println(n)
}

Branche conditionnelle de l'instruction if

Une expression conditionnelle est spécifiée après si, et lorsque cette condition est satisfaite, l'intérieur de {} est exécuté.

  package main
  func main(){

    score := 100
    if score > 80{
 printnl ("bien joué")
   }
  }
Opérateur de comparaison
x <= y Tient lorsque x est inférieur ou égal à y
x >= y Tient lorsque x est supérieur ou égal à y

Valeur booléenne (OUI ou NON)

Il existe deux valeurs pour «type de validité», «vrai» et «faux». Une expression conditionnelle utilisant un opérateur de comparaison a la valeur "true" lorsqu'elle est maintenue et "false" lorsqu'elle ne l'est pas.

package main
 func main(){
  println(3 > 2)
  println(3 > 5)
}
 > _ Console
ture
false
opérateur
== Ture quand les côtés gauche et droit sont égaux
!= Quand ce n'est pas égal
< Vrai quand le côté droit est plus grand
<= Lorsque le côté droit est plus grand ou égal
> Quand le côté droit est petit
>= Quand le côté droit est petit ou égal

eles

En combinant << else >> avec l'instruction if, "If ..., do .... If not, do ...." Vous pourrez faire une branche conditionnelle 
  package main
    func main(){
    score := 50
     if score > 80 {
 println ("bien joué")
 } else {
 println ("Faisons de notre mieux")
   }
}

eles if

package main
 func main() {
  score := 70
  if score == 100{
 println ("bien joué")
} eles if score >= 60{
 println ("juste")
} eles{
 println ("OK")
　　}
}

:dancer: eles if (2)

package main
  func main() {
    score := 100
  if score == 100{
 println ("bien joué")
} eles if score >= 60{
  
 println ("juste")
} else {

 println ("Faisons de notre mieux")
　}
}

: ancre: et (&&) opérateur théorique

L'expression conditionnelle "si la condition 1 et la condition 2 sont satisfaites" est écrite comme "condition 1 && condition 2" en utilisant "&&". && correspond à "Katsu" en japonais. La combinaison de plusieurs expressions conditionnelles à l'aide de && se traduira par vrai dans son ensemble uniquement si toutes les expressions conditionnelles sont vraies


package main 
   func main() {
       time := 14
    if time > 10 && time < 18 {
        

 println ("heures de travail")
　　}
}

Ou(||)

L'expression conditionnelle "que la condition 1 ou la condition 2 soit satisfaite" est "||"Condition 1"||Écrivez comme "Condition 2".||Est équivalent à "ou" en japonais. ||Lorsque plusieurs expressions conditionnelles sont combinées à l'aide de, si même l'une des multiples expressions conditionnelles est vraie, le tout devient vrai.

package main 
  func main() {
       time := 15
     if time == 10 || time == 15 {
 println ("objectif")
　　　}
}

: poignard: Déni (!)

 package main 
     func main(){

      time := 9
   if !(time == 18) {
 println ("ne pas laisser le temps")
 }
}

swich

　  case 0:
 println ("mauvais")

　　case 1, 2:
 println ("Kichi")

　　case 3, 4:
 println ("Nakayoshi")
　　case 5:
 println ("Daikichi")