Top Banner

Click here to load reader

Fundamentos de Scala (Scala Basics) (español) Catecbol

Jan 22, 2018

ReportDownload

Technology

  1. 1. Capacitacin Tecnolgica Cientfica para BoliviaCatecbol La unin es la fuerza facebook.com/catecbol @catecbol [email protected] Fundamentos de Scala University of Applied Sciences and Arts Western Switzerland, HES-SO Jean-Paul Calbimonte
  2. 2. Jean-Paul Calbimonte Formacin acadmica: Ingeniera de Sistemas: Universidad Catlica Boliviana, Bolivia Master en Informtica: cole Polytechnique Fdrale de Lausanne EPFL, Suiza Doctorado en Inteligencia Artificial: Universidad Politcnica de Madrid, Espaa Experiencia: Investigador adjunto, University of Applied Sciences and Arts Western Switzerland Postdoctorado, cole Polytechnique Fdrale de Lausanne EPFL, Suiza Software dev: pirAMide informatik, medspazio, Cochabamba rea de Investigacin: Procesamiento de streams, RDF streams, ingeniera ontolgica, e-Health http://jeanpi.org
  3. 3. Fundamentos de Scala Qu es Scala? lenguaje escalable tipos estticos orientado objetos + funcional sintaxis concisa corre en JVM compatible con Java abstraccin concurrencia, multi-hilos ecosistema Scala
  4. 4. Scala: ideas bsicas 2. toda funcion es un valor 1. todo valor es un objeto Scala combina ambos paradigmas
  5. 5. Scala: un vistazo
  6. 6. Prueba Scala en lnea ahora mismo! http://tinsmith.herokuapp.com/
  7. 7. Scala: expresiones y tipos 1 //> res0: Int(1) = 1 true //> res1: Boolean(true) = true 2+3 //> res2: Int(5) = 5 2.4+3 //> res3: Double(5.4) = 5.4 math.Pi //> res4: Double(3.141592653589793) = 3.141592653589793 math.log(1) //> res5: Double = 0.0 "cadena" //> res6: String("cadena") = cadena "cadena" + 4 //> res7: String = cadena4 3/0 //> java.lang.ArithmeticException: / by zero cada expresin es una funcin que resulta en un valor cada valor tiene un tipo de dato, e.g. Int, String 2+3 //> res2: Int(5) = 5
  8. 8. Scala: diseccionando una expresin 2+3 //> res2: Int(5) = 5 2.+(3) //> res8: Int(5) = 5 se puede escribir como: objeto argumento mtodo "34".toInt < 20 //> res9: Boolean = false
  9. 9. val num=3 //> num : Int = 3 println(num) //> 3 val texto="catecbol" //> texto : String = catecbol val num2:Int=3 //> num2 : Int = 3 val mix="texto"+34+true //> mix : String = texto34true var num3=3 num3 = 5 // no se puede reasignar un val num2 = 5 // no se puede reasignar con otro tipo num3 = "texto" Scala: valores y variables se infiere el tipo declaracin explcita
  10. 10. (s:String) => "cadena" + s //> res0: String => String = val sumarPi = (num:Int) => Pi+num //> sumarPi : Int => Double = sumarPi(23) //> res1: Double = 26.141592653589793 val calcular=(n1:Int,n2:Double) => { val n3=n1*n2 n3*5 } //> calcular : (Int,Double) => Double = calcular(3,4.5) //> res2: Double = 67.5 Scala: funciones parmetro funcin annima cuerpo de la funcin val puede ser una funcin
  11. 11. Scala: colecciones val arr1=Array(3,5,6,4) //> arr1 : Array[Int] = Array(3, 5, 6, 4) val arr2=Array(Array(5,4,2) Array(3,2,4), Array(1,5,4)) arr1(2) //> res0: Int = 6 arr2.flatten //> res1: Array[Int] = Array(5,4,2,3,2,4,1,5,4) val arr3=ArrayBuffer(3,2,4) //> scala.collection.mutable.ArrayBuffer[Int] arr3+=4 //> res2: ArrayBuffer(3, 2, 4, 4)
  12. 12. Scala: colecciones val map1=Map("cbba"->"Cochabamba", "lp" ->"La Paz", "tri" ->"Trinidad") map1("cbba") //> res3: String = Cochabamba map1.getOrElse("abc", "ninguno") //> res4: String = ninguno val bol=("bol","Bolivia") val chi=("chi","Chile") val arg=("arg","Argentina") Seq(bol,chi,arg).toMap //> res5: scala.collection.immutable .Map[String,String] map1.asJava //> res6: java.util.Map[String,String]
  13. 13. Scala: listas List(1,3,5,6,9) //> res0: List[Int] = List(1, 3, 5, 6, 9) Seq(3,6,8,9) //> res1: Seq[Int] = List(3, 6, 8, 9) (1 to 6) //> res2: Range(1, 2, 3, 4, 5, 6) (0 until 10) //> res3: Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) val lista=(1 to 5) //> lista: Range(1, 2, 3, 4, 5) lista.filter(i => i res4: Vector(1, 2, 3) lista.filter(i=>i%2==0) //> res5: Vector(2, 4) lista.map(i=>i*2) //> res6: Vector(2, 4, 6, 8, 10) lista.sum //> res7: Int = 15 lista.foreach(i => println(s"*$i*")) //> *1* //| *2* //| *3* //| *4* //| *5*
  14. 14. Scala: listas val lista2=List(3,5.6,45,"hola",34.5,"chau") lista2.head //> res8: Any = 3 lista2.take(3) //> res9: List[Any]=List(3, 5.6, 45) "adios" :: lista2 //> res10: List(adios, 3, 5.6, 45, hola, 34.5, chau) List(20,30) ::: List(40,50) //> res11: List(20, 30, 40, 50) lista2.map { case s:String=>"*" case _ => "+" } //> res12: = List(+, +, +, *, +, *)
  15. 15. Scala: cadenas val s1="cadena" //> s1 : String = cadena s1.split('a') //> res0: Array[String] = Array(c, den) val s2=s"$s1 es un string" //> s2 : String = cadena es un string val num=34.56 //> num : Double = 34.56 val s3=f"$s1 y un valor de $num%2.1f" //> s3 : String = cadena y un valor de 34.6 val s4="""cadena de varias lneas""" //> s4 : String = cadena de //| varias //| lneas
  16. 16. Scala: cadenas "ab,cd,ef;gh;ij".split(",|;") //> res1: Array[String] = Array(ab, cd, ef, gh, ij) val r="[a-z]+".r //> r : scala.util.matching.Regex = [a-z]+ r.findFirstIn("2653abc7878") match { case Some(patron)=>patron } //> res2: String = abc
  17. 17. Scala: clases class Banda(nombre:String,genero:String) val kjarkas=new Banda("Kjarkas","folclore") class Musico(val nombre:String,banda:Banda) { def cantar(cancion:String)={ println(s" $cancion ") } } val elmer=new Musico("Elmer Hermosa",kjarkas) elmer.cantar("bolivia") //> bolivia println(elmer.nombre) //> Elmer Hermosa println(elmer.banda)
  18. 18. Scala: clases class Instrumento(nombre:String,esAutoctono:Boolean=false){ override def toString= s"El instrumento: $nombre" } val charango=new Instrumento("charango",true) val bajo=new Instrumento("bajo") println(bajo) //> El instrumento: bajo
  19. 19. Scala: traits trait Artista{ val nombre:String val edad:Int } class Cantante(val nombre:String, val edad:Int, val discos:Int) extends Artista class Actor(val nombre:String,val edad:Int,val peilculas:Int) extends Artista val luzmila=new Cantante("Luzmila Carpio",50,30 val jenny=new Actor("Jenny Serrano",40,2) val artistas=Seq(luzmila,jenny) artistas.foreach(artista=>println(artista.nombre)) //> Luzmila Carpio //| Jenny Serrano
  20. 20. Scala: clases class Cancion(val titulo:String) trait Cantante{ def cantar(cancion:Cancion) } trait Compositor{ def componer(titulo:String):Cancion } class Cantautor extends Cantante with Compositor{ def componer(titulo:String)={ new Cancion(titulo) } def cantar(cancion:Cancion)= println(s" ${cancion.titulo} ") } val matilde=new Cantautor val regreso=matilde.componer("Regreso") matilde.cantar(regreso) //> Regreso
  21. 21. Scala: objetos singleton class Departamento(val nombre:String) object Cochabamba extends Departamento("Cochabamba") object Beni extends Departamento("Beni") def iniciales(dpto:Departamento)= dpto.nombre.take(3) iniciales(Beni) //> res0: String = Ben object Departamento{ def apply(s:String)=new Departamento(s) } Departamento("Tarija") object Geometria { def area(radio:Int)=math.Pi*radio*radio } Geometria.area(4) //> res2: Double = 50.26548245743669
  22. 22. Scala: clases case case class PlatoTipico(nombre:String,departamento:String) val majao=PlatoTipico("majadito","Santa Cruz") val fricase=PlatoTipico("fricase","La Paz") println(majao.departamento) //> Santa Cruz val majadito=PlatoTipico("majadito","Santa Cruz") majao == majadito //> res0: Boolean = true val sonso=majao.copy(nombre="sonso") println(sonso) //> PlatoTipico(sonso,Santa Cruz)
  23. 23. Scala: match case def evaluar(nota:String)={ nota match { case "A" => 70 case "B" => 50 case "F" => 30 case _ => 0 } } //> evaluar: (nota: String)Int evaluar("B") //> res0: Int = 50 evaluar("h") //> res1: Int = 0 def verificar(a:Any)=a match{ case "A" => "una letra A" case 4 => "un int 45" case 4.5 => "un double 4.5" } //> verificar: (a: Any)String verificar("A") //> res2: String = una letra A // match error verificar("a")
  24. 24. Scala: match case def verificar2(a:Any)=a match { case s:String => "string" case d:Double => "double" case i:Int => "int" case _ => "otro" } //> verificar2: (a: Any)String Seq("ab",5,3.4,"2",List).map(verificar2) //> res3: Seq[String] = List(string, int, double, string, otro)
  25. 25. Scala: match case trait Region{ val nombre:String } case class Departamento(nombre:String) extends Region case class Provincia(nombre:String,dpto:Departamento) extends Region case class Municipio(nombre:String,prov:Provincia) extends Region val cocha=Departamento("Cochabamba") val cercado=Provincia("Cercado",cocha) val chuqui=Departamento("Chuquisaca") val oropeza=Provincia("Oropeza",chuqui) val sucre=Municipio("Sucre",oropeza) val list:Seq[Region]=Seq(cocha,cercado,oropeza,sucre)
  26. 26. Scala: match case val list:Seq[Region]=Seq(cocha,cercado,oropeza,sucre) list map { case Departamento(nom) => s"Depto $nom" case Provincia(nom,dpto) => s"prov $nom en ${dpto.nombre}" case Municipio(nom,prov) => s"muni $nom en ${prov.nombre}, dpto ${prov.dpto.nombre}" } //> res4: Seq[String] = List(Depto Cochabamba, prov Cercado en Cochabamba, prov //| Oropeza en Chuquisaca, muni Sucre en Oropeza, dpto Chuquisaca) list map { case d:Departamento => s"Depto ${d.nombre}" case p:Provincia => s"prov ${p.nombre} en ${p.dpto.nombre}" case m:Municipio => s"muni ${m.nombre} en ${m.prov.nombre}, dpto ${m.prov.dpto.nombre}" } //> res5: Seq[String] = List(Depto Cochabamba, prov Cercado en Cochabamba, prov //| Oropeza en Chuquisaca, muni Sucre en Oropeza, dpto Chuquisaca)
  27. 27. Scala: opciones val equipos=Map("lp"->"The Strongest", "scz"-