Chisel 学习笔记（一）
Scala基础语法
变量和常量
在scala中关键字var表示变量，val表示常量， 使用常量可以增强代码可读性，减少变量重复使用的可能
值得注意的是，Scala行末没有分号，但如果一行里有多条语句，分号则是必要的
var numberOfKittens = 6
val kittensPerHouse = 101
val alphabet = "abcdefghijklmnopqrstuvwxyz"
var done = false
numberOfKittens += 1
// kittensPerHouse = kittensPerHouse * 2 // kittersPerHouse是不可重载的，所以这一行会导致不能编译
println(alphabet)
done = true
条件语句
Scala的条件语句和其他语言类似，单行语句可以不用{}包围，但多行语句需使用大括号
// A simple conditional; by the way, this is a comment// A si
if (numberOfKittens > kittensPerHouse) {
println("Too many kittens!!!")
}
// The braces are not required when all branches are one liners. However, the
// Scala Style Guide prefers brace omission only if an "else" clause is included.
// (Preferably not this, even though it compiles...)
if (numberOfKittens > kittensPerHouse)
println("Too many kittens!!!")
// ifs have else clauses, of course
// This is where you can omit braces!
if (done)
println("we are done")
else
numberOfKittens += 1
// And else ifs
// For style, keep braces because not all branches are one liners.
if (done) {
println("we are done")
}
else if (numberOfKittens < kittensPerHouse) {
println("more kittens!")
numberOfKittens += 1
}
else {
done = true
}
Scala中的if语句是有返回值的，他的返回值是所执行if分支的最后一条语句
valval likelyCharactersSetlikelyC = if (alphabet.length == 26)
"english"
else
"not english"
println(likelyCharactersSet)
方法和函数
函数的声明
方法的关键词是def，他的参数表是由逗号分开的，参数均为 参数名:类型 的形式 其后接上返回值的类型，如下：
// Simple scaling function with an input argument, e.g., times2(3) returns 6
// Curly braces can be omitted for short one-line functions.
def times2(x: Int): Int = 2 * x
// More complicated function
def distance(x: Int, y: Int, returnPositive: Boolean): Int = {
val xy = x * y
if (returnPositive) xy.abs else -xy.abs
}
没有参数的函数可以不写括号，按照惯例，没有任何副作用，仅仅返回值的函数不写括号；但是改变了外部参数，有标准输出等存在副作用的无参函数要写括号
函数的重载
同样的函数名可以通过不同的参数类型进行重载，如下：
// Overloaded function
def times2(x: Int): Int = 2 * x
def times2(x: String): Int = 2 * x.toInt
times2(5)
times2("7")
子函数和递归调用
函数内部可以声明子函数，但其子函数只在当前函数内可见
/** Prints a triangle made of "X"s/** Pri
* This is another style of comment
*/
def asciiTriangle(rows: Int) {
// This is cute: multiplying "X" makes a string with many copies of "X"
def printRow(columns: Int): Unit = println("X" * columns)
if(rows > 0) {
printRow(rows)
asciiTriangle(rows - 1) // Here is the recursive call
}
}
// printRow(1) // This would not work, since we're calling printRow outside its scope
asciiTriangle(6)
列表
列表和数组有一些区别，列表可以支持添加和提取等操作
val x = 7
val y = 14
val list1 = List(1, 2, 3)
val list2 = x :: y :: y :: Nil // list2里面有x, y, y三个元素，Nil表示列表结束
val list3 = list1 ++ list2 //把第二个列表添加到第一个列表之后
val m = list2.length
val s = list2.size
val headOfList = list1.head // 取得列表第一个元素
val restOfList = list1.tail // 取得列表除去第一个元素后的所有元素
val third = list1(2) // 取得第三个元素，列表起始下标是0
更多List操作：https://blog.csdn.net/zengxiaosen/article/details/59490379
for循环
从0循环到7（包括7）
for (i <- 0 to 7) { print(i + " ") }
println()
从0循环到7（不包括7）
for (i <- 0 until 7) { print(i + " ") }
println()
从0循环到10（包括10）步长2
for(i <- 0 to 10 by 2) { print(i + " ") }
println()
迭代器
val randomList = List(util.Random.nextInt(), util.Random.nextInt(), util.Random.nextInt(), util.Random.nextInt())
var listSum = 0
for (value <- randomList) {
listSum += value
}
println("sum is " + listSum)
类
Scala中的类和Java中的类相似，都需要先创造出实例再使用，一个类的例子如下
class WrapCounter(counterBits: Int) { //类的构造器需要一个传入的参数
val max: Long = (1 << counterBits) - 1
var counter = 0L //类中一些变量的声明
def inc(): Long = { //类中的方法
counter = counter + 1
if (counter > max) {
counter = 0
}
counter //方法的返回值要写在最后一行
}
println(s"counter created with max value $max") //这句println在类中，视为类初始化的一部分，每次实例化该类时会打印，可在debug时使用
}
类的实例化
val x = new WrapCounter(2)
x.inc() // 两种调用类中方法的方式
x inc()
if(x.counter == x.max) { // 没有声明成private的数据可以随意访问
println("counter is about to wrap")
}
另外考虑以下代码，可以看出在参数声明和使用时可以通过指定参数名或者默认参数值，降低代码出错的可能性，并提高可读性
def myMethod(count: Int, wrap: Boolean, wrapValue: Int = 24): Unit = { ... }
myMethod(count = 10, wrap = false, wrapValue = 23)
myMethod(wrapValue = 23, wrap = false, count = 10)
myMethod(wrap = false, count = 10)
``