x <- c(5,12,13)
for(n in x) print(n^2) 

i <- 1
while(i <= 10) i <- i+4
i

i <- 1
while(TRUE){
  i <- i+4
  if (i>10) break
}
i```

#repeat语句对主体部分求值直到明确的要求退出

相当于while(1)

i<-1
repeat{
i <- i+4
if(i>10) break
}
i```

next,停止本次循环，进入循环的下次迭代，避免使用复杂的if-else

a <- sample(1:100,10,replace = FALSE)
a[11] <- 2
for (i in a){
  if(i %% 2 ==0){
    print("this is an even number.")
    if(i==2){
      print("oh,it's 2")
      next      
    }
    else{
      print("this is an odd number")
    }
  }
  print(paste("the number is ",as.character(i),"."))
}```

#R不支持直接对非向量集合进行循环，使用get()函数完成循环

注意get()的参数接收代表对象名字的字符串参数，返回对象的内容

u <- matrix(c(1,2,3,4,5,6),nrow=2)
v <- matrix(c(23,34,54,65),nrow=2)
for (m in c("u","v")){
z<-get(m)
print(lm(z[,2]~z[,1]))
}```

if-else语句会返回最后赋予的值

x <- 2
y <- if(x==2) x else x+1
if(x==2) y<-x else y<-x+1
#if的大括号是必须的
if(x==2){
  x <- 1
}else{
  x <- 3
  y <- 4
}```

#向量使用&，而标量作为特殊的向量使用&或者&&都可以

然后if判断条件只能使用一个逻辑值，因此就会有用

x <- c(TRUE,TRUE,FALSE)
y <- c(TRUE,FALSE,TRUE)
x && y
x & y
x[1] && y[1]

TRUE和FALSE可以简写为T和F```

返回值

#如果不使用return()语句，将会把最后执行的语句的值作为返回值
#返回值通常为列表的形式
oddcount <- function(x){
  k <- 0
  for (n in x){
    if (n %% 2 ==0){
      k <- k+1
    }
  }
  k
  #return(k)
}```

#函数对象

x <- 1:4
g <- function(x){
t <- function(x){
return(x^2)
}
return(t)
}
t <- g(x)
t(x)

将函数对象打印出来

查看函数代码，直接输入对象名称，

或者篇幅很长page(function),edit(function),

但是基本的函数如sum不能这样做因为是c语言写的

g1 <- function(x) return(sin(x))
g2 <- function(x) return(sqrt(x^2+1))
g3 <- function(x) return(2*x-1)
plot(c(0,1),c(-1,1.5))

plot.function draws a curve corresponding to a function over the interval [from to]

add=T if T add to an already existing plot

for(f in c(g1,g2,g3)) plot(f,0,1,add=T)```

不明白的地方

g <- function(h,a,b) h(a,b)
body(g) <- quote(2*x+3)```

#环境和作用域

函数-闭包closure,环境

w <- 12
f <- function(y){
d <- 8
h <- function(){
#print(ls())
print(ls(envir = parent.frame(n=1)))
return(d*(w+y))
}
return(h())
}

输出为R_GlobalEnv表示在顶层环境

environment(f)

ls()会返回当前的局部变量，使用envir参数

ls()会输出函数调用链中的任何一个框架的局部变量名

ls()

parent.frame(n=1)表示沿函数调用链向上追溯1个框架

ls(envir = parent.frame(n=1))```

函数没有副作用

#不改变非局部变量,f中的局部变量和w开始时候共享一个地址，但是当f中的w改变的时候
#就会分配新地址给w
w <- 12
f <- function(y){
  d <- 8
  w <- w+1
  y <- y-2
  print(w)
  #h()创建的时候就创建了对应的局部变量，因此会掩盖上层环境的同名变量
  h <- function(){
    return(d*w+y)
  }
  return(h())
}
#全局变量在函数中是只读,除非使用超赋值运算符<<-```

#一个显示框架层次环境的函数

showframe <- function(upn){

determine the proper environment

if(upn < 0){
env <- .GlobalEnv
}else{
env <- parent.frame(n=upn+1)
}

get the list of variable names

vars <- ls(envir = env)

for each variable name, print its value

for(vr in vars){
#处理环境层次结构的多个层次，因此使用envir参数设定层次
vrg <- get(vr,envir=env)
if(!is.function(vrg)){
#如果不是函数的话，将值打印出来
cat(vr,":\n",sep = "")
print(vrg)
}
}
}

f <- function(){
a <- 1
return(g(a)+a)
}

g <- function(aa){
b <-2
aab <- aa + b

向上追溯一个框架，也就是g中的变量，因为showframe也占用了一个框架

showframe(0)

向上追溯2个框架，也就是f中的变量

showframe(1)
return(aab)
}

f()```

R--编程结构(一)