Ruby or Rails 学习总结 2

2020-03-30 本文已影响0人 Qo_Tn

Qo_Tn

第三章学习

3.1 创建字符串

String：

单引号或双引号创建。
单引号字符串只能进行最少替换。
双引号字符串对于括起来的字符串能进行更多替换。例如替换转义字符串和其他特殊字符。

字符串	含义
\a	替换成Bell 声所对应的符号
\nnn	nnn表示一个八进制数值，替换成该八进制所对应的字符
\b	退格符，替换成退格键所对应的字符
\xnn	xnn 表示一个十六进制数值，替换成该十六进制数所对应的字符
\e	替换Escape键所对应的字符
\cx	替换成Ctrl+X 组合键所对应的字符，其中x可以是任意键对应的字符
\C-x	替换成Ctrl+X 组合键所对应的字符，其中x可以是任意键对应的字符
\n	换行符，替换成一个空行
\M-x	替换成Alt+X 组合键所对应的字符串，其中x可以是任意键对应的字符
\r	回车符，替换成一个回车
\M-\C-x	替换成Ctrl+Alt+X组合键所对应的字符串，其中x可以是任意键对应的字符
\s	空白符，替换成一个空白字符
\t	替换成一个Tab键所对应的字符
\v	替换成一个垂直Tab键所对应的字符
#{expr}	替换成变量或者表达式expr所对应的值

3.2 操作字符串

String类和 Sysbol类

这两个类提供了文本功能，通过使用这两个类中的方法可以操作字符串。
'+' 合并两个或两个以上字符串
'<<' 为已有字符串变量永久性地增加另一个字符串。
'#{}' 嵌入字符串变量，返回新的字符串
拼接字符串还可以使用乘法运算，即一个字符串复制出相应倍数字符串的链接
内置 replace 方法可以替换字符串中的内容
dup、clone 方法来复制字符串
dup 只能复制字符串的内容
clone 除了内容以外，还继承了特殊方法、污染(taint)、冻结(freeze)等信息
改变字符串的方法

方法	说明
capitalize	将字符串首字母转换为大写
upcase	将字符串中所有的字母转换为大写
downcase	将字符串中所有的字母转换为小写
swapcase	将字符串中大写字母转为小写，小写字母转为大写
strip	去掉字符串中的首尾空格
Lstrip	去掉字符串中左边的空格
Rstrip	去掉字符串中右边的空格
Chop	删除字符串中的最后一个字符
chomp	删除字符串中的最后的换行符
reverse	将字符串中反转过来

获取字符和子字符串用 '[ ]' , '[ ]' 方法的参数是字符的索引，该方法返回一个字符，可以使用ord方法把字符转换为 ASCII 值。为 [ ] 方法添加两个参数，还可以从字符串中获取指定长度的子字符串。
当字符串索引: 正左负右，正0负-1 。
'==' 比较是否相等
'<=>' 比较字符串的大小 -1 0 1

例如：

puts "-------------------------------------------------------------------------- "
#合并字符串
a="合并"
b="字符串"
c=a+b
puts c
puts "-------------------------------------------------------------------------- "
a<<b   # 为已有的字符窜增加另一个字符串
puts a
puts b
puts "-------------------------------------------------------------------------- "
puts "#{a}#{b}"
puts "-------------------------------------------------------------------------- "
puts "#{a}#{b}"*3

puts "-------------------------------------------------------------------------- "
#替换字符串
str="替换的字符串"
a=str
str.replace("这里用来替换内容")
puts str
puts a

#复制字符串
str="复制字符串的内容"
puts str.dup
puts str.clone

#改变字符串
str="abcdefgWWW，大写"
puts str.upcase
    
#获取字符和子字符串
str="abcdefgWWW.help"
puts str[2]
puts str[7].ord
puts str[4,5]
puts str[-3]
puts str[100]
#比较字符串
str="比较字符串,str"
itzcn="比较字符串,itzcn"
if str==itzcn
    puts "这两个字符串内容想等"
else
    puts "这两个字符串内容不相等"
end

#大小
puts 'a'.ord                #输出a的ASCII 值
puts 'b'.ord                #输出b的ASCII 值
puts 'b'<=>'a'            #比较大小，将返回1
if ("a">"b")        # 比较大小，将返回false
    puts "a大于b"
else
    puts "a小于b"
end

3.3 Hash对象

哈希表时最常用的索引集合之一，用来保存数据
Hash 类似于 Dictionary
可动态添加实例

Hash对象常用的方法:

方法	说明
size()	返回Hash对象的长度
length()	返回Hash对象的长度
include?(key)	判断指定的Hash 对象是否包含指定的key
has_key?(key)	判断指定的Hash 对象是否包含指定的key
delete(key)	删除Hash 对象中指定key的对应元素
keys()	返回由Hash 对象中全部key组成的数组
values()	返回由Hash对象中全部value 组成的数组

Hash对象的迭代器方法:

迭代器方法	说明
each	迭代输出Hash对象里面的全部元素(包括key 和 value)
each_key	迭代输出Hash对象里面所有key
each_pair	迭代输出Hash对象里所有key-value对
each_value	迭代输出Hash对象里所有value

#Hash 对象
person={    #创建Hash对象
    "name"=>"Tom",
    "age"=>25,
    "sex"=>"男"
}

puts person

persons=Hash.new    #创建Hash类实例
persons["name"]="Tom"        #添加元素
persons["age"]=25
persons["sexx"]="男"
puts persons

puts persons.size()
puts persons.length()
puts persons.include?("name")
puts persons.has_key?("age")
persons.delete("sexx")
puts persons

puts persons.keys()
puts persons.values()


# Hash 迭代方法
 persons.each do |name|
        p "1#{name}"
 end

p persons.each_key
p persons.each_pair
p persons.each_value

3.4 数组

数组事数据对象的集合
带有索引的集合，都是动态的，长度可变
数组的索引可以为正数，也可以为负数，正0负-1 原则
使用size方法来访问数组的长度

将多个空格的字符串转换为数组，使用%w{...}或者%W{...}表示法，这两种表示法功能大致相同。使用大些W的方法，会对内部转义字符和特殊字符进行替换。

方法	说明
unshift()	向数组的头部添加数组元素
push()	向数组的尾部添加数组元素
<<	向数组的尾部添加一个数组元素
shift	向数组头部删除数组元素
pop	向数组的尾部删除数组元素
array[n,m]	截取从索引n开始，长度为m的元素列表，组成新数组
array[n..m]	截取从索引n开始, 到索引m的元素列表(包括索引m的数字元素)，组成新数组
array[n...m]	截取从索引n开始，到索引m的元素列表(不包括索引为m的数组元素), 组成新数组

例如：

#数组
food=["大米","小米","黑米","虾米","红米","玉米","粟米"]
p food

food[5]="水果"
p food

food[8]="玉米"
p food

food=Array.new
food[0]="大米"
p food

str=%W{上海\s自来水\s来自\s海上}   #使用%W
str2=%w{上海\s自来水\s来自\s海上}   #使用%w
p str
p str2

#添加删除
food.unshift("小米")
food.push("黑米")
food<<"玉米"

p food

#food.shift
#food.pop
#p food

a=food[1,2]
b=food[1..2]
c=food[1...2]

p a,b,c

food_1=["大米"]
food_2=["小米","香蕉"]
food_1.concat(food_2)
p food_1
p food_2

3.5 类型转换

类型转换

方法说明

to_s 将获取的对象转换为字符串

to_i 将获取的对象转换为整数

to_f 将获取的对象转换为浮点

方法	说明
to_s	将获取的对象转换为字符串
to_i	将获取的对象转换为整数
to_f	将获取的对象转换为浮点

class Computer              #定义Computer 类
    def initialize(name)        #定义构造函数
        @name=name
    end
    def to_s                    #定义to_s方法
        "电脑型号: #{@name}"
    end
end

computer=Computer.new("方正") #实例化Computer 类
puts computer.to_s          # 调用to_s方法
puts computer                  # 输出car对象


pinpai="诺基亚"
xinghao="5000"
color="紫色"
shangshi_date="2008年5月"
price="410"
sale=0.8

puts "品牌："+pinpai
p "型号："+xinghao
p "颜色："+color
p "上市时间："+shangshi_date
p "市场价格："+price
p "优惠价格："+(price.to_i*sale).to_s

第四章学习

4.1 面向对象

对象、类、对象的状态、对象的行为、类的关系、对象的消息
封装、继承、多态

4.2 创建类

类的定义和使用
- class 声明 end 结束
```
class Animal
# 这里写类的结构
end
```

类中的表达式

#类的表达式
class Animal
puts "这里定义了一个Animal类"
puts "这里在Animal类中打印了两行文本"
end

self 关键字

class Animal
    puts self
    puts self.class
    def put 
        puts self
        puts self.class
    end
end 

a = Animal.new
a.put

追加类
- 定义好一个类以后，还可以对其进行追加操作。只要是同名的类，对其进行添加功能。在使用类时，系统会自动将两个或多个同名的类合并使用。
```
class Animal
    def put
        p "这是put方法"
    end
end

class Animal
    def show
        p "这是show方法"
    end
end

a=Animal.new
a.put
a.show    
```

嵌套类

类中声明另外一个类
嵌套类用‘ :: ’来引用

class Animal
    class Head
        def put
            puts "这里Head类里的put方法"
        end
    end
end

h=Animal::Head.new
h.put

特殊类
- 在Ruby 中还允许为某个特定的对象追加一些方法和属性，这些方法和属性封装到一个类中直接追加到对象中。这个类没有特定的类名，所以并不能作为普通的类使用，所以我们称其为特殊类。
```
class Animal
#一个空的Animal类
end
a=Animal.new
class <<a
    def put
        puts "这个是特殊类的put方法"
    end
end
a.put   
```

4.3 方法

方法是类中执行其行为的成员，类的所有行为都将以方法的形式来进行执行和处理
脱离了类，也可以使用方法，不过在没有类的情况下定义的方法我们通常称之为“函数”

方法如下

def methodName(arg1, arg2, ....argN)
       #方法体
end

参数可以不用括号来标识，如果省略括号，方法名和参数列表之间需要有空格进行分隔，调用方法时使用的括号也可以省略。

class Animal
   def eat(food)
       puts "这个动物正在吃"+food
   end
end
ani=Animal.new
ani.eat("馒头")

参数的默认值

class Dog
    def eat(food="骨头")
            puts "小狗正在吃"+food
    end
end 
dog=Dog.new
dog.eat("肉")
dog.eat

方法的返回值

class Dog
    def GetHobi
        "肉"
    end

    def GetWeight
        return "12kg"
    end
end

dog=Dog.new

puts "小狗喜欢吃#{dog.GetHobi}"
puts "小狗的体重为#{dog.GetWeight}"

特殊方法

class Dog
    # 一个空的Dog类
end
dog=Dog.new
def dog.show
    puts "我是一个只有12kg体重的小胖狗"
end
dog.show

定义类的方法

类方法需要使用类名和点运算符做为方法名的前缀

class Dog
    def Dog.show
        puts "我是一只有12kg体重的小胖狗"
    end
end
Dog.show

类的方法不一定要声明在类中，它可以在类的外部单独声明。
类的方法声明在类中，可以使用self关键字来代替类名

4.4 实例变量和类变量

实例变量

实例变量用于在类内部共享数据
声明位置顶部、顶部方法、类、类方法、模块、模块方法
实例变量以@开头

@Name="Tom"

class Cat
    @Color="黄色"
    def init
        @weight="3kg"
    end
    def show
            puts "#@Name 是一只 #@Color 的有#@weight 体重的小懒猫"
    end
end 
cat=Cat.new
cat.init
cat.show

类变量

位置与实例变量相同
类变量需要以两个“@”开头

@@master="张浩华"
class Cat
    def say
        puts "我是一只小懒猫，我的主人是#@@master"
    end
end
class Dog
    def say
        puts "我是一只小笨狗，我的主人是#@@master"
    end
end
cat=Cat.new
cat.say
dog=Dog.new
dog.say

4.5 属性

属性对类的外部提供了一个访问类内部实例变量的接口，我们可以通过它来操作类的实例变量

属性读取器和设置器

class Person
    def name
        @name
    end
end
p=Person.new
puts p.name

如果要为类的实例变量追加一个设置器，我们还要为其创建一个设置方法
设置实例变量值的属性方法比较特殊，命名时需要以等号“=”为后缀，并且必需设置一个方法参数
```
class Person
    def name=(val)
        @name=val
    end
end
p=Person.new
p.name="joker"
```
属性定义标识符
- 四个标识符: attr 、attr_reader 、 attr_writer 、attr_accessor
- 四个标识符为内建方法
```
class 类名
    attr:attr1,key
    attr_reader:attr1,attr2
    attr_writer:attr1,attr2
    attr_accessor:attr1,attr2
end
```
- 这里的 :attr1 是类中实例变量的名称，不过这里要把实例变量名称的前缀at符号“@”换成冒号“:”
- attr 根据布尔型数据key的值，定义一个可读写的属性。如果key的值为false，则设置属性的访问权限为只读
- attr_reader 定义一个或多个只读的属性
- attr_writer 定义一个或多个只写的属性
- attr_accessor 定义一个或多个可以读写的属性
```
 class Dog
   attr:name,true
   attr_reader:weight
 end
```

4.6 构造方法

构造方法是在实例化类时要执行的类的方法，且该方法在创建每一个类的实例的时候都会被调用。
构造方法可以接收 0个或多个参数，这样就可以在初始化类的对象的时候直接为该对象的实例变量设置初始值。

构造方法的名称统一为 initialize ,也就是说当调用类的 new 方法创建类的实例的时候，系统会自动调用 initialize 方法来初始化该对象。

class Car
    def initialize(brand,color)
        @brand=brand
        @color=color
    end
    def show
        puts "这是一辆 #@color 的 #@brand 轿车。"
    end
end
car=Car.new("BYD","红色")
car.show

class Pekingese
    def initialize(name,color,hobi)
        @name=name
        @color=color
        @hobi=hobi
    end
    
    def sayHello
            puts "汪汪"
            puts "我是 #@name"
            puts "我是 #@hobi"
    end
    
    attr_accessor :name, :color, :weight, :hobi
end

dog=Pekingese.new("小强","白色","吃肉")
puts "这里我们得到一只 #{dog.color} 的小狗，\n让它来给我们打个招呼: \n汪汪 \n我是小强 \n我喜欢吃肉"

dog.sayHello

4.7 在方法中使用块

Ruby 重用性 => 代码块
代码块用话括号的方式和 do-end 语句的方式。
```
{
    #代码块内容
}

do
    #代码块内容
End
```
代码块可以作为一个参数传递给方法，然后方法中可以使用yield 关键字调用传入的代码块
```
def say
    puts "Hello"
    yield
    puts "Bye"
end
say do 
    puts "What you say?"
end
```
代码块添加参数，方法体中使用 yield 关键字调用代码块的时候传入参数，在带参数的代码块中需要以 “|arg1,arg2|” 的格式声明参数。
```
def say
    name="joker"
    puts "Hello,I'm"+name
    yield name 
end
say do |name|
    puts "Hello,"+name
end
```
代码块不只能有参数，还可以具有返回值。和一般的方法一样，代码块的返回值也是使用最后一个表达式的值，而且在方法中也可以获取和使用代码块的返回值。
```
def say
    puts yield
end
say do 
    "Hello,Joker"
end
```

4.8 类的继承

继承可以共享父类的成员，实现代码的复用。
继承可以使子类直接使用父类的方法和变量，等于说一个类的另外一个类开辟了特殊的访问权限。
在类的继承中，被继承的类称为基类，也可以称为父类; 继承基类的类称为派生类，也可以称为子类。
子类继承父类最大的特点就是实现饿了代码的重用，因为子类可以从父类中获取父类中已有的属性和方法。
方法：'<' 后追加一个父类的名称即可
子类继承父类的元素

super 关键字主动的调用父类的同名方法，如果父类的构造方法中有参数列表，可以使用super关键字追加这个参数列表。

class Bird
    #这是一个鸟类
end
class Chick<Bird
    #这是一个小鸡类
end
class Bird
    def  initialize
        @wing=2
    end
end
class Chick<Bird
    def show
        puts "这只小鸡有 #@wing 只翅膀"
    end
end
chick=Chick.new
chick.show

4.9 访问作用域

访问作用域关键字 private、protected、public
private 私有方法，被该方法指定的成员只可以被该类内部访问，成员对类外部是不可见的。
protected 保护方法，被该方法指定的成员可以被任何隶属的子类访问。
public 公有方法，被该方法指定的成员可以被任何类或对象调用，没有访问权限。(成员声明时默认就是 public、initialize 方法除外)

声明类属性一样将方法名作为参数传递给三个作用域控制方法来指定访问级别

class Bird
    def fly # 前面没有访问修饰，默认为public
    end
    
    private  #定义为私有方法
    def eat
    end

    protected  # 定义为 保护的方法
    def run
    end
    
    public  # 定义为公有的方法
    def jump
    end
end

class Bird

    def fly
    end
    
    def eat
    end
    
    def run
    end
    
    def jump
    end
    private(:eat)                   # 定义为私有方法
    protected(:run,:jump)     # 定义为保护的方法
end

Ruby or Rails 学习总结 2

第三章学习

3.1 创建字符串

3.2 操作字符串

例如：

3.3 Hash对象

3.4 数组

3.5 类型转换

第四章学习

4.1 面向对象

4.2 创建类

4.3 方法

4.4 实例变量和类变量

4.5 属性

4.6 构造方法

4.7 在方法中使用块

4.8 类的继承

4.9 访问作用域

猜你喜欢

热点阅读

Ruby or Rails 学习总结 2

第三章学习

3.1 创建字符串

3.2 操作字符串

例如：

3.3 Hash对象

3.4 数组

3.5 类型转换

第四章学习

4.1 面向对象

4.2 创建类

4.3 方法

4.4 实例变量 和 类变量

4.5 属性

4.6 构造方法

4.7 在方法中使用块

4.8 类的继承

4.9 访问作用域

猜你喜欢

热点阅读

4.4 实例变量和类变量