精华内容
下载资源
问答
  • '''内部定义的函数,分为两大类: 一:绑定方法:绑定给谁,就应该由谁来调用,谁来调用就会把调用者当作第一个参数自动传入 1.绑定到对象的方法类内定义的没有任何装饰器修饰的 2.绑定到类的方法类...

    '''
    在类内部定义的函数,分为两大类:
    一:绑定方法:绑定给谁,就应该由谁来调用,谁来调用就会把调用者当作第一个参数自动传入
        1. 绑定到对象的方法:在类内定义的没有被任何装饰器修饰的

        2. 绑定到类的方法:在类内定义的被装饰器@classmethod修饰的方法

    二:非绑定方法:没有自动传值这么一说了,就类中定义的一个普通工具,对象和类都可以使用
        非绑定方法:不与类或者对象绑定,在类内定义的被装饰器@staticmethod修饰的方法

    说明:未做任何修饰时:在类内定义的方法是绑定给对象的,对象调用时,不需要传自己给self. 类调用类的方法时,需要传self(对象)给第一个参数。


    '''

    class Foo:
        def __init__(self,name):
            self.name=name
    
        def tell(self):
            print('名字是%s' %self.name)
    
        @classmethod
        def func(cls): #cls=Foo
            print(cls)
    
        @staticmethod
        def func1(x,y):
            print(x+y)
    
    f=Foo('egon')
    
    # print(Foo.tell)
    # Foo.tell(f)
    # print(f.tell)
    
    # f.tell()
    
    # print(Foo.func)
    # Foo.func()
    
    # print(Foo.func1)
    # print(f.func1)
    
    Foo.func1(1,2)
    f.func1(1,3)
    

      

    应用:

    import settings
    import hashlib
    import time
    
    class People:
        def __init__(self,name,age,sex):
            self.id=self.create_id()
            self.name=name
            self.age=age
            self.sex=sex
    
        def tell_info(self): #绑定到对象的方法
            print('Name:%s Age:%s Sex:%s' %(self.name,self.age,self.sex))
    
        @classmethod
        def from_conf(cls):
            obj=cls(
                settings.name,
                settings.age,
                settings.sex
            )
            return obj
    
        @staticmethod
        def create_id():
            m=hashlib.md5(str(time.time()).encode('utf-8'))
            return m.hexdigest()
    
    # p=People('egon',18,'male')
    
    #绑定给对象,就应该由对象来调用,自动将对象本身当作第一个参数传入
    # p.tell_info() #tell_info(p)
    
    #绑定给类,就应该由类来调用,自动将类本身当作第一个参数传入
    # p=People.from_conf() #from_conf(People)
    # p.tell_info()
    
    
    #非绑定方法,不与类或者对象绑定,谁都可以调用,没有自动传值一说
    p1=People('egon1',18,'male')
    p2=People('egon2',28,'male')
    p3=People('egon3',38,'male')
    
    print(p1.id)
    print(p2.id)
    print(p3.id)
    

      

    转载于:https://www.cnblogs.com/beallaliu/p/9114244.html

    展开全文
  • 中都可以访问到容易引起“命名冲突”②函数内部变量:作用范围为当前函数内部没有块级作用域范围,所以在方法任何地方声明的变量都是整个方法中有效。、④声明变量可以用“var”,也可不用,不用“var...

    全局变量:在页面上直接声明的变量,全局是指在整个当前页面都能访问到的变量;

    默认属于windows成员

    直到页面关闭或浏览器关闭才释放资源

    在每个<script></script>中都可以访问到

    容易引起命名冲突

    函数内部变量:作用范围为当前函数内部

    没有块级作用域范围,所以在方法中任何地方声明的变量都是在整个方法中有效。、

    声明变量可以用“var”,也可不用,不用“var”声明的变量是全局变量;

    js中同样不能有重名的变量,js发现变量重复后悔自动忽略后面的声明,只是用第一次声明的变量

    注:推荐在js声明变量时要用var,且少使用全局变量

    (5) 数据类型转换

    字符串转化数字 

    字符串转换为整数: parseInt (numString, [radix]) radix 为要解析的字符串的基数。该值介于 2 ~ 36之间。如果省略该参数或其值为 0,则数字将以 10 为基础来解析。如果它以 “0x” “0X” 开头,将以 16 为基数。如果该参数小于 2 或者大于 36,则parseInt() 将返回 NaN

    字符串转化为小数:parseFloat(numString)

    任意类型到指定类型

    转为字符串: String (object)、对象.toString()

    转为Boolean Boolean (object)

    转化为数字: Number (object)

     NaN :当某类型转化为数字失败时,返回NaN,表示不是一个数字;NaN不等于任何值,包括它自己,判断时需要使用isNaN(arg)函数

    (6) eval () 函数

    eval() 函数可将字符串转换为代码执行,并返回一个或多个值.

    如果eval函数在执行时遇到错误,则抛出异常给调用者.

    类似的函数是 loadcode ,loadcode并不立即执行代码,而是返回一个函数对象.

    并且loadcode支持路径参数,eval并不支持. eval并不支持代码中的return语句,而是将代码作为表达式直接计算出结果.

    注:不推荐使用,效率低且不安全局变量:在页面上直接声明的变量,全局是指在整个当前页面都能访问到的变量;

    默认属于windows成员

    直到页面关闭或浏览器关闭才释放资源

    在每个<script></script>中都可以访问到

    容易引起命名冲突

    函数内部变量:作用范围为当前函数内部

    没有块级作用域范围,所以在方法中任何地方声明的变量都是在整个方法中有效。、

    声明变量可以用“var”,也可不用,不用“var”声明的变量是全局变量;

    js中同样不能有重名的变量,js发现变量重复后悔自动忽略后面的声明,只是用第一次声明的变量

    注:推荐在js声明变量时要用var,且少使用全局变量

    (5) 数据类型转换

    字符串转化数字 

    字符串转换为整数: parseInt (numString, [radix]) radix 为要解析的字符串的基数。该值介于 2 ~ 36之间。如果省略该参数或其值为 0,则数字将以 10 为基础来解析。如果它以 “0x” “0X” 开头,将以 16 为基数。如果该参数小于 2 或者大于 36,则parseInt() 将返回 NaN

    字符串转化为小数:parseFloat(numString)

    任意类型到指定类型

    转为字符串: String (object)、对象.toString()

    转为Boolean Boolean (object)

    转化为数字: Number (object)

     NaN :当某类型转化为数字失败时,返回NaN,表示不是一个数字;NaN不等于任何值,包括它自己,判断时需要使用isNaN(arg)函数

    (6) eval () 函数

    eval() 函数可将字符串转换为代码执行,并返回一个或多个值.

    如果eval函数在执行时遇到错误,则抛出异常给调用者.

    类似的函数是 loadcode ,loadcode并不立即执行代码,而是返回一个函数对象.

    并且loadcode支持路径参数,eval并不支持. eval并不支持代码中的return语句,而是将代码作为表达式直接计算出结果.

    注:不推荐使用,效率低且不安全

    展开全文
  • 如果 lambda 表达式不能直接在函数体内显示引用自身,那么我们就得隐式地调用自身;因为我们不是用循环来模拟递归,我们就是要让 lambda 表达式反复执行一段相同代码。 其中一个策略是,将 ...
  • 函数方法没有本质区别,但函数类的内部使用。以前C#中只有方法,从.NET 3.5开始才有了匿名函数。 所以,我们最好叫递归方法,而非递归函数,本文中将统一称之为递归。 应用程序中为什么要使用递归?何时使用...
  • JS中函数的两种定义方法

    万次阅读 2020-07-02 14:22:52
    定义函数 JavaScript中,定义函数的...{ … }之间的代码是函数体,可以包含若干语句,甚至可以没有任何语句。 请注意,函数内部的语句执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数

    定义函数

    在JavaScript中,定义函数的方式如下:

    function abs(x) {
    if (x >= 0) {
    return x;
    } else {
    return -x;
    }
    }
    上述abs()函数的定义如下:

    function指出这是一个函数定义;
    abs是函数的名称;
    (x)括号内列出函数的参数,多个参数以,分隔;
    { … }之间的代码是函数体,可以包含若干语句,甚至可以没有任何语句。
    请注意,函数体内部的语句在执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。

    如果没有return语句,函数执行完毕后也会返回结果,只是结果为undefined。

    由于JavaScript的函数也是一个对象,上述定义的abs()函数实际上是一个函数对象,而函数名abs可以视为指向该函数的变量。

    因此,第二种定义函数的方式如下:
    var abs = function (x) {
    if (x >= 0) {
    return x;
    } else {
    return -x;
    }
    };
    在这种方式下,function (x) { … }是一个匿名函数,它没有函数名。但是,这个匿名函数赋值给了变量abs,所以,通过变量abs就可以调用该函数。

    上述两种定义完全等价,注意第二种方式按照完整语法需要在函数体末尾加一个;,表示赋值语句结束。

    展开全文
  • 内部函数(转)

    2009-07-02 13:07:00
    但Kernel模块中定义的方法(可以在任何地方用做函数,因此)可被其他语言当做函数来调用.若您对这些方法进行再定义时,就必需考虑到对其他方面的影响.` str把字符串str当做外部命令来运行,并以字符串方式返回命令的输出....

    严格说来,Ruby中没有函数.但Kernel 模块中定义的方法(可以在任何地方用做函数,因此)可被其他语言当做函数来调用.若您对这些方法进行再定义时,就必需考虑到对其他方面的影响.

    ` str

    把字符串str 当做外部命令来运行,并以字符串方式返回命令的输出.使用`str` 形式来调用该方法(还可以使用%x(...) 表示法进行调用.请参考命令输出 ).

    可以使用$? 来了解命令的结束状态.

    若您只想执行命令,而不需要得到命令输出时,可以使用system .如果是那些终端控制命令的话,`command` 可能会运行失败.

    Array(arg )

    调用 arg .to_ary 或 arg .to_a 将参数转为数组并返回结果.若变换后没有得到数组就会引发TypeError 异常.

    arg 中没有to_ary或to_a方法的话,就返回只包含一个元素的数组[arg ].

    Float(arg )

    将参数变为浮点数(Float )并返回结果.

    若将不能转为整数或浮点数的字符串传递给参数的话,会引发ArgumentError 异常.

    请参考String#to_f .

    p Float("10")    # => 10.0
    p Float("10e2") # => 1000.0
    p Float("1e-2") # => 0.01
    p Float(".1") # => 0.1

    p Float("nan") # => NaN (ruby 1.7 特性: => invalid value (ArgumentError))
    p Float("INF") # => Infinity (ruby 1.7 特性: => invalid value (ArgumentError))
    p Float("-Inf") # => -Infinity (ruby 1.7 特性: => invalid value (ArgumentError))
    p Float(("10" * 1000).to_f) # => Infinity

    p Float("0xa.a") # => 10.625 # (ruby 1.7 特性: => invalid value (ArgumentError))
    p Float(" /n10") # => 10.0 # 前面的空白被忽略
    p Float("1_0_0") # => 100.0 # `_' 也被看做是数值要素
    p Float("") # => invalid value (ArgumentError)
    p Float(nil) # => 0.0 # ruby1.7特性: cannot convert nil into Float (TypeError)

    p Float(Object.new) # => cannot convert Object into Float (TypeError)
    Integer(arg )

    将参数变为整数(Fixnum ,Bignum )并返回结果.对数值,字符串以外的对象使用to_i方法(Ruby 1.7 特性 :在1.7中是to_int).若变换结果不是整数(Integer 的子类)就会引发TypeError 异常.

    若参数是字符串的话,将按其前缀,如0x,0b,0等分别决定要按照16进制,2进制或是8进制的标准来处理该字符串.

    若把不能变为整数的字符串传递给参数时,将引发ArgumentError 异常.

    p Integer(10.1)       # => 10
    p Integer(10.8) # => 10
    p Integer("10") # => 10
    p Integer("10_0_0") # => 1000
    p Integer("10__0") # => 100
    # => invalid value for Integer: "10__0" (ArgumentError) (ruby 1.7 特性)
    p Integer("_10") # => invalid value for Integer: "_10" (ArgumentError)
    p Integer("10_") # => invalid value for Integer: "10_" (ArgumentError)
    p Integer("0d10") # => invalid value for Integer: "0d10" (ArgumentError)
    # => 10 (ruby 1.7 特性)
    p Integer("010") # => 8
    p Integer("0o10") # => invalid value for Integer: "0o10" (ArgumentError) (ruby 1.7 特性)
    # => 8
    p Integer("0x10") # => 16
    p Integer("0b10") # => 2
    p Integer(" /n10/t ") # => 10
    p Integer("") # => `Integer': invalid value for Integer: "" (ArgumentError)
    p Integer(nil) # => 0

    p Integer(Object.new) # => cannot convert Object into Integer (TypeError)

    请参考String#hex ,String#oct ,String#to_i .

    String(arg )

    调用arg .to_s 将参数变为字符串并返回结果。若变换后的结果并非字符串的话,会引发TypeError 异常。若arg 已经是字符串的话,则不作任何处理直接返回arg

    abort
    abort(message ) ((<ruby 1.7 特性 >))

    以非正常方式结束Ruby程序的运行。它与Exit 的区别在于,调用时若$! 不为nil的话,就将异常消息输出到标准错误输出当中;另外,程序的结束status始终都是EXIT_FAILURE(在绝大多数环境中都是1)。

    ruby 1.7 特性 :若指定了message 参数的话,就将message 赋值给SystemExit#message 后输出到标准错误输出中。

    at_exit { .... }

    在解释器结束工作之前执行指定的块。除去at_exit 是个方法这点差异之外,它与END 块所进行工作基本相同。一旦注册了要进行的处理内容之后就不能取消。请参考结束时的相关处理

    Proc 对象返回注册的处理内容。

    autoload(const_name , feature )
    autoload?(const_name ) ((<ruby 1 .8 feature >))

    在首次调用常数const_name 时会require featureconst_name 可以是字符串或Symbol 。而且const_name 中不能包含"::"操作符(即只能指定顶层的常数)。

    返回nil

    ruby 1.8 特性 :可以autoload任何类/模块的常数。const_name 中还是不能有"::"操作符,可以像下面这样定义。(实际上是调用了Module#autoload )

    ------- /tmp/foo.rb ---------
    class Foo
    class Bar
    end
    end
    ----- end of /tmp/foo.rb ----

    class Foo
    autoload :Bar, '/tmp/foo.rb'
    end
    p Foo::Bar

    另外,还可以下面这样定义。

    class Foo
    end
    Foo.autoload :Bar, '/tmp/foo.rb'
    p Foo::Bar

    autoload? 的功能是,若autoload常数尚未定义(没被load)时,返回其路径名。另外,若已经load的话就返回nil。

    ------- /tmp/foo.rb ---------
    class Foo
    class Bar
    end
    end
    ----- end of /tmp/foo.rb ----

    class Foo
    end
    Foo.autoload :Bar, '/tmp/foo.rb'
    p Foo.autoload?(:Bar) # => "/tmp/foo.rb"
    p Foo::Bar # => Foo::Bar
    p Foo.autoload?(:Bar) # => nil

    请注意下例。在autoload的库中,嵌套内的常数还没有被定义。乍看起来好像会正常运行,实则不然(出现了警告消息)。

    ------- /tmp/bar.rb ---------
    class Bar
    end
    ----- end of /tmp/bar.rb ----

    class Foo
    autoload :Bar, '/tmp/bar.rb'
    end
    p Foo::Bar
    p Foo.autoload?(:Bar)

    # => -:4: warning: toplevel constant Bar referenced by Foo::Bar
    Bar
    nil

    若不使用嵌套的话,可以把上例简写为

    class Foo
    end
    class Bar
    end
    p Foo::Bar

    # => -:5: warning: toplevel constant Bar referenced by Foo::Bar
    Bar
    binding

    生成并返回Binding 对象。该对象包含变量、方法等的环境信息,它通常用作Eval 的第二参数。

    caller([level ])

    $@ 的back trace(字符串数组)形式返回level 层上(省略参数时为1)的调用者的信息。若是顶层的话就返回空数组。将caller的返回值代入$@就可以设定异常的发生位置。

    def foo
    p caller(0)
    p caller(1)
    p caller(2)
    p caller(3)
    end

    def bar
    foo
    end

    bar

    => ["-:2:in `foo'", "-:9:in `bar'", "-:12"]
    ["-:9:in `bar'", "-:12"]
    ["-:12"]
    []

    下列函数可以从caller的要素中抽取并返回[文件名、行号、方法名]。

    def parse_caller(at)
    if /^(.+?):(/d+)(?::in `(.*)')?/ =~ at
    file = $1
    line = $2.to_i
    method = $3
    [file, line, method]
    end
    end

    def foo
    p parse_caller(caller.first)
    end

    def bar
    foo
    p parse_caller(caller.first)
    end

    bar
    p parse_caller(caller.first)

    => ["-", 15, "bar"]
    ["-", 19, nil]
    nil

    $DEBUG 为真时,debug函数非常有用。以下是该函数例程。

    def debug(*args)
    p [caller.first, *args] if $DEBUG
    end

    debug "debug information"

    => ["-:5", "debug information"]
    callcc {|cont | .... }

    请参考Continuation

    catch(tag ) {|tag | .... }

    运行块并返回它的值。若在块的运行过程中,遇到与tag 同名的throw 的话,将把throw的第二参数的值作为返回值。

    例如下例代码在运行过程中不会调用some_process ,同时catch的值是25,而并非10。

    ret = catch(:exit) {
    throw :exit, 25
    some_process()
    10
    }
    p ret #=> 25

    嵌套的循环不会因为遇到break 就一下子跳出。这时可使用catch或异常

    catch(:loop1) {
    for i in 1..2
    for j in 1..2
    throw :loop1, j
    end
    end
    }
    chop
    chop!

    将内部变量$_ 末尾的字符去掉(若末尾是"/r/n"则去掉2个字符)。chop!将改变字符串本身并返回结果。若没有可以去掉的字符则返回nil。

    请参考String#chop 了解详情。chop函数与$_.chop之间存在以下区别。

    • chop先拷贝$_的值,然后对拷贝进行修改,最后把这个拷贝的值重新赋值 给$_。
    chomp([rs ])
    chomp!([rs ])

    去掉位于内部变量$_ 末尾且由rs 指定的字符。chomp!将改变字符串本身并返回结果。若没有可被去掉的字符串则返回nil。rs 的默认值为$/

    请参考String#chomp 了解详情。chomp函数与$_.chomp之间存在以下区别。

    • chomp先拷贝$_的值,然后对拷贝进行修改,最后把这个拷贝的值重新赋值 给$_。
    eval(expr [, binding [, fname [, lineno =1 ]]])

    把字符串expr 当作Ruby程序来运行并返回其结果。若给第二参数传递Proc 对象或Binding 对象的话,将在生成该对象的环境中对字符串进行计算。请参考binding

    def foo
    a = 1
    binding
    end

    eval("p a", foo) # => 1

    若指定了fnamelineno 的话,将假定字符串位于fname 文件lineno 行,并且进行编译。这时可以显示栈跟踪(stack trace)等信息。

    exec(command )
    exec(program [, arg1 [, arg2 [, ...]]])

    执行由command 指定的命令.该命令(或shell,详见下文)将变成进程执行的代码,所以一旦启动成功,就不会再从该函数中返回.若启动失败,控制权重新回归ruby解释器,然后会引发Errno::EXXX 异常.

    在第一种语句中,若command 中包含shell的元字符(* ? {} [] <> () ~ & | / $ ; ' ` " /n)的话,则经由shell执行命令.除此之外,将由解释器直接执行.

    使用第二种语句时,通常不经过shell就执行命令.此时,将把空字符或shell的元字符等原般不动地传递给program 的参数.若首个参数是包含两个元素的数组时,第一个元素的字符串将成为启动程序时的路径,而第二个元素将成为程序名的"别名".

    ruby 1.8 特性 :即使第一个元素不是完整路径,也会自动从环境变量PATH中开始搜索.

    exit([status ])

    终止Ruby程序的运行.若向status 传递了一个整数的话,该整数就将成为Ruby命令的结束状态值.默认的结束状态值是0.

    exit 通过引发SystemExit 异常来结束程序的运行.若有必要的话,可以使用rescue 部分来捕捉到它.

    ruby 1.8 特性 :若statustrue 的话,就以EXIT_SUCCESS 作为结束状态值.若statusfalse 的话,就以EXIT_FAILURE 作为结束状态值.默认的结束状态值已被改为EXIT_SUCCESS .

    exit!([status ])

    以整数status 为结束状态值来终止Ruby程序的运行.默认的结束状态值为-1.

    exit!exit 不同,它不会进行异常处理.在fork 之后,若想终止子进程时可以使用该语句.

    ruby 1.8 特性 :若statustrue 的话,就以EXIT_SUCCESS 作为结束状态值.若statusfalse 的话,就以EXIT_FAILURE 作为结束状态值.默认的结束状态值已被改为EXIT_FAILURE .

    fork
    fork { ... }

    使用fork(2) 系统调用来制作进程的拷贝.若在父进程中将返回子进程的进程ID,若在子进程中则返回nil.若指定一个块之后再进行调用,则会在生成的子进程中对该块进行计算.

    gets([rs ])
    readline([rs ])

    Ruby解释器在运行时,会把从参数那里得到的文件(若没有的话,就利用标准输入)假设成一个虚拟文件(可以使用内部变量$<ARGF 访问该虚拟文件),然后从该虚拟文件中读入一行,并返回字符串.若到达文件尾部时返回nil.

    使用rs 指定的字符串作为行的切分符号.rs 的默认值取自内部变量$/ .读入的字符串也被存入内部变量$_ 中.

    若将rs 设为nil的话,则意味着读入文件的全部内容而忽略行的切分.若设为空字符串""的话,会把连续的换行当做行的切分符(段落模式).

    readline 的功能与gets 相同,但是当它遇到文件结尾时会引发EOFError 异常.

    global_variables

    返回程序中已定义的全局变量(以'$'开头的变量)名的数组.

    另外请参考local_variables , Object#instance_variables , Module.constants , Module#constants , Module#class_variables .

    gsub(pattern [, replace ])
    gsub!(pattern [, replace ])
    gsub(pattern ) {|matched | ... }
    gsub!(pattern ) {|matched | ... }

    在内部变量$_ 所包含的字符串中,将符合pattern 的部分替换为replace ,然后返回结果.若省略参数replace 时,该方法将演变为迭代器,以块的计算值进行替换操作.将匹配的字符串以参数的形式传递给块.

    $_ = "foobar"
    p gsub(/o+/) {|m|
    m.upcase
    }
    # => "fOObar"

    gsub!将改写$_所包含的字符串本身.请参考String#gsub 来获得更多资讯.String#gsub和gsub之间存在以下差异.

    • gsub方法会拷贝$_的值,然后对拷贝进行更新,最后再赋值 给$_.
    iterator? ((<obsolete >))
    block_given?

    若某方法带块则返回真,否则返回伪.

    load(file [, priv ])

    加载Ruby程序file 并予以执行.若file 是绝对路径,则从file 开始加载.若file 是相对路径,则依次搜索内部变量$: 所指定的路径,并加载第一个搜索到的文件.此时,若$:中的元素是以"~"(tilde)开头的话,就把它扩展为环境变量HOME的值.

    若可选参数priv 的值为真,则在内部生成一个无名模块作为顶层来进行加载和运行,这便不会污染全局名字空间了.

    若加载成功则返回true,若失败则引发LoadError 异常.

    [require与load之间的区别]

    require对于相同的文件只会加载一次,而load则是无条件的加载.另外,require会自动补全扩展名,如.rb或.so等.而load则没有该功能.一般的典型用法是,使用require加载库,而使用load加载配置文件等.

    # 用例
    load "#{ENV['HOME']}/.myapprc"
    load "/etc/myapprc"

    另外,如果想在特定目录中加载文件的话,写成 load 'filename' 就不恰当了.这时请务必使用绝对路径.

    local_variables

    返回当前作用域中已定义的局部变量名的数组.

    另外,请参考global_variables , Object#instance_variables , Module.constants , Module#constants , Module#class_variables .

    loop { ... }

    (只要不被中断就)反复对块进行计算.

    open(file [, mode [, perm ]])
    open(file [, mode [, perm ]]) {|io | ... }

    打开file 并返回File 对象.mode 可以是下列字符串或者整数(File::Constants 模块的常数的逻辑和).省略时默认为"r".

    • "r", RDONLY: 以读取模式打开文件.
    • "w", WRONLY|CREAT|TRUNC: 以写入模式打开文件.打开文件时,若文件已存在就清空文件内容.
    • "a", WRONLY|CREAT|APPEND: 以写入模式打开文件.通常 把写入内容添加到文件结尾.

    若有"+"的话,就以读写两用模式(RDWR)打开文件.

    • "r+": 将文件的读写位置设在开头.
    • "w+": 与"r+"一样.打开文件时,若文件已存在就清空其内容.
    • "a+": 与"r+"一样.打开文件时,若文件已存在,就把读写位置设在文件结尾.

    可在上述任意一项后面添加"b"(如"r+b")标志(如果是整数就是File::BINARY).此时,将以二进制方式打开文件(只限于以文本/二进制方式来区分文件的系统).

    第三参数permopen(2) 的第三参数是一样的,它以整数的形式说明了文件在CREAT时的访问权限。若第二参数不是数值形式的话,该参数将被忽略。它的默认值是0666。

    若文件名以`| '开头时,其后的字符串会被当作命令来执行。另外,将生成管线(pipeline)来应对命令的标准输入输出。

    若文件名为"|-" 的话,open 将生成Ruby的子进程,并返回与子进程之间的管道(pipe)(IO 对象)。(此时的运作与IO.popen 相同。File.open 没有生成管线的功能)。

    注意 : 与Perl不同的是,命令通常是以`| '开头的。

    open 与块同时被调用时,open 将打开文件并执行块,当块的运行终止后就关闭文件。此时返回块的计算结果。请看下例。

    open(path, mode) do |f|
    ...
    end

    # 等效代码
    f = open(path, mode)
    begin
    ...
    ensure
    f.close
    end
    p(obj , [obj2 , ...])

    以通俗易懂的方式输出obj 。等同于以下代码。(请参考Object#inspect )

    print obj.inspect, "/n", obj2.inspect, "/n", ...

    返回nil

    print([arg1 [, arg2 , ...]])

    依次输出参数。若没有得到参数则输出变量$_ 的值。若把非字符串对象传给参数的话,将对该对象使用to_s方法将其变为字符串后输出。若是nil的话则输出字符串"nil"。

    若给变量$; (输出字段分隔符)指定了一个非nil的值的话,将在各个参数之间输出该分隔符。若给变量$/ (输出记录分隔符)指定了一个非nil的值的话,将在最后输出它。

    返回nil

    printf([port , ]format [, arg [, ...]])

    类似于C语言的printf,它将按照format 将参数格式化为字符串,然后输出到$> 。当第一参数是IO 的子类的实例时,将对该对象进行输出。若没有任何参数时,将不作反应。

    请参考sprintf格式 来了解Ruby中format字符串的扩展问题。

    返回nil

    proc { ... }
    lambda { ... }
    proc
    lambda

    在给出的块中生成过程对象(Proc 的实例)并返回它(等同于Proc.new )。

    若没有给出块的话,将返回主调(caller)方法所指的块。若主调方法没有块时,将引发ArgumentError 异常。

    putc(ch )

    将字符ch 输出到$> 。若ch 是数字的话,将输出对应于0~255的字符。若ch 是字符串的话,将输出字符串中的第一个字符。

    返回ch

    putc("ch")
    putc(?c)
    putc(99)
    # => ccc
    puts([obj [, obj2 [, ....]]] )

    依次将obj 和换行符输出到$> 。若没有参数的话则只会输出换行符。

    若参数是数组,则依次输出数组元素和换行符。若将既非数组又非字符串的对象传递给参数时,将尝试使用to_ary方法将其化为数组,再使用to_s方法将其化为字符串。若是nil则输出字符串"nil"。

    若参数是以换行符结尾时,puts将不再输出换行符。

    puts "foo", "bar/n", "baz"
    puts "" # 只输出换行
    puts # 只输出换行
    puts "foo"
    => foo
    bar
    baz


    foo

    返回nil

    另外,请参考print , warn

    raise
    raise(exception )
    raise(message )
    raise(error_type , message [, backtrace ])
    fail(error_type , message [, backtrace ])

    引发异常。

    若没有参数时,将再次引发本线程本块内最后被rescue的异常对象($! )。若没有这样的异常时,将引发RuntimeError 异常。

    begin
    open("nonexist")
    rescue
    raise # => `open': No such file or directory - "nonexist" (Errno::ENOENT)
    end

    若只有一个参数,且该参数为字符串时,将以该字符串为message来引发RuntimeError异常。若该参数为异常类或异常对象时,将引发该异常。

    raise "error message"    # => -:1: error message (RuntimeError)

    raise ArgumentError # => -:1: ArgumentError (ArgumentError)

    raise ArgumentError.new # => -:1: ArgumentError (ArgumentError)

    若有2或3个参数时,将以第二参数为message来引发第一参数所指的异常。此时是以异常类或异常对象来指定异常的。而第三参数则是发生异常时的栈跟踪(track trace),它的形式必须与caller 的返回值一致。

    raise ArgumentError, "error message"
    # => -:1: error message (ArgumentError)

    raise ArgumentError, "error message", ["file1:99",
    "file2:999:in `method'"]

    # => file1:99: error message (ArgumentError)
    from file2:999:in `method'

    若将非异常的类或对象赋予第一参数时,实际上发生的异常正是该对象的exception方法的返回值。

    class MyException
    def exception
    ArgumentError.new
    end
    end

    raise MyException.new

    # => -:7: ArgumentError (ArgumentError)

    若采用第二种形式来指定参数时,该参数将被赋予exception 方法。

    class MyException
    def exception(mesg)
    ArgumentError.new(mesg)
    end
    end

    raise MyException.new, "error message"

    # => -:7: error message (ArgumentError)

    exception 方法必定返回异常对象。否则将引发TypeError

    发生的异常会被存入变量$! 中。而发生异常时的栈跟踪信息将被存入变量$@ 中。

    rand([max =0 ])

    产生一个0至max (不含)之间的随机数。若未调用srand 的话,就自动调用它。

    若将max 设为nil 或0的话,将返回一个0至1(不含)的实数型Float 随机数。

    readlines([rs ])

    把从命令行参数那里得到的文件(若没有的话,就利用标准输入)假设成一个虚拟文件(ARGF ),再读入该文件的所有内容,然后以行为单位将这些内容转换为数组,最后返回该数组。

    rs 所指的字符串为行的切分符。rs 的默认值取自内部变量$/

    若将rs 设为nil 则意味着没有行切分符。若设定为空字符串"",则把连续换行当作行切分符(段落模式)。

    require(feature )

    从加载路径$: 开始搜索Ruby库feature ,若该库尚未被加载就立即加载。

    Ruby库就是指Ruby脚本(*.rb )或扩展库(*.so ),若feature 的扩展名被省略时,则会同时搜索这两种文件(欲知具体的搜索顺序,请参考$: )。若给出扩展名时,则只会搜索这种文件。另外,扩展库的扩展名不仅限于常用的那些,还常常使用.so。

    加载库后返回true。若该库已被加载则不会重复加载,此时返回false。若加载失败则引发LoadError 异常。feature 被加载后,它的名字(包括扩展名)会被追加到变量$" 中。

    scan(re )
    scan(re ) {|matched | ... }

    $_.scan 一样。

    select(reads [, writes [, excepts [, timeout ]]])

    IO.select 一样。

    set_trace_func(trace_proc )

    在Ruby解释器执行程序的过程中,每当发生方法调用或对表达式进行计算等事件时都将执行trace_proc 过程对象。、以及等标准附件就是使用该内部函数来实现的。

    例:

    set_trace_func lambda {|event, file, line, id, binding, klass|
    # ....
    }

    块参数的意义如下。

    event

    表示发生事件的类别。详细内容如下。

    • "line" ... 表达式的计算。
    • "call" ... 方法调用。
    • "return" ... 从方法调用中返回。
    • "c-call" ... C(语言)方法的调用。
    • "c-return" ... 从C(语言)方法调用中返回。
    • "class" ... 进入类定义、特殊类定义或模块定义中。
    • "end" ... 类定义、特殊类定义或模块定义的结束。
    • "raise" ... 发生异常。
    file

    运行中的程序的源文件名(字符串)。

    line

    运行中的程序的源文件行号(整数)。

    id

    根据event 的不同,将使用下列之一。与第六个块参数klass 相对应。

    line

    Symbol 对象,它表示最后被调用的方法。在顶层中则为nil

    call/return/c-call/c-return

    Symbol 对象,它表示被调用/return的方法。

    class/end

    nil

    raise

    Symbol 对象,它表示最后被调用的方法。在顶层中则为nil

    binding

    Binding 对象,它表示运行中的程序的状况(context)。

    klass

    根据event 的不同,将使用下列之一。与第四个块参数id 相对应。

    line

    Class 对象,它表示最后被调用的方法的所属类。在顶层中则为false。

    call/return/c-call/c-return

    Class 对象,它表示被调用/return的方法的所属类。

    class/end

    false

    raise

    Class 对象,它表示最后被调用的方法的所属类。在顶层中则为false。

    sleep([sec ])

    使程序暂停sec 秒。也可以将sec 设为浮点数。省略sec 时,若没有显式地(SIGALRM或其他线程发出的Thread#run )终止睡眠的话,将一直sleep下去。返回值是实际睡眠的秒数(整数)。

    spawn(cmd , [arg , ...]) ((<ruby 1 .9 特性 >))

    基本上等同于system ,但它不会等待子进程的结束。返回生成的子进程的进程ID。

    split([sep [, limit ]])

    使用sep 模型将$_ 中的字符串分割成limit 个部分后转化为数组,然后返回该数组。请参考String#split 以获得更多的资讯。

    sprintf(format ... )
    format(format ... )

    采用同C语言sprintf一样的方法对format 字符串进行解释,格式化参数后返回结果。使用format 时,就好像使用C语言sprintf一样。

    Ruby对整数的大小没有上限,因此把负数指定给%b, %o, %x 时(可看作左边有无数个1),就会显示成..f。若想以“符号加绝对值”的形式进行输出的话,就得写成%+x% x 这样。

    请参考sprintf格式化 来获取更多资讯。

    srand([seed ])

    设定rand 的随机数的种子,返回旧的初始值(第一次返回0)。若省略初始值时,则以当前时刻、进程ID或srand的调用次数为基础生成一个种子。

    sub(pattern [, replace ])
    sub!(pattern [, replace ])
    sub(pattern ) {|matched | ... }
    sub!(pattern ) {|matched | ... }

    在内部变量$_ 所指的字符串中,将首个匹配pattern 的部分替换为replace ,然后返回结果.若省略参数replace 时,该方法将变为迭代器,以块的计算值进行替换操作.将匹配的字符串以参数的形式传递给块.

    sub!将改写$_所包含的字符串本身.请参考String#sub 来获得更多资讯.String#sub和sub之间存在以下差异.

    • sub方法会拷贝$_的值,然后对拷贝进行更新,最后再赋值 给$_.
    syscall(num , arg ... )

    执行num 号码所对应的系统调用。将第二参数以后的部分传给系统调用作为其参数。参数必须是字符串或整数。

    请参考syscall(2) 或 /usr/include/sys/syscall.h 以了解数值与系统调用的对应关系。

    Ruby遵从系统调用的习惯,若syscall(2) 返回-1时,引发Errno::EXXX 异常。若返回其他值则不作变动。

    system(command )
    system(program [, arg1 [, arg2 [, ...]]])

    执行command ,成功(子进程以 status 0 的状态结束时)则返回真,失败(包括不能执行命令)则返回伪。可参照变量$? 来获取结束状态值(status)。

    当不能执行命令时,大多数的shell会返回状态值127。(所以$?的值为0x7f00)若没有使用shell时,Ruby子进程以状态值127结束。通常,查看$?的值即可区分是不能执行命令还是命令失败。

    ruby 1.9 特性 :不能执行命令时会引发Errno::EXXX 异常。若使用了shell,则同上所述。

    请参考exec 以获取更多资讯。

    另外,请参考`command` ,open

    test(cmd , file1 [, file2 ])

    进行文件测试。cmd 可以是下列数值字面值 或字符串(只把字符串的首字符当成命令)。

    • 带一个参数时
      • ?r

        可以使用有效 uid 读取文件

      • ?w

        可以使用有效 uid 写入文件

      • ?x

        可以使用有效 uid 执行文件

      • ?o

        文件的所有者是有效 uid

      • ?G

        文件的所有者group是有效 gid

      • ?R

        可以使用实 uid 读取文件

      • ?W

        可以使用实 uid 写入文件

      • ?X

        可以使用实 uid 执行文件

      • ?O

        文件的所有者是实 uid

      • ?e

        文件存在

      • ?z

        文件大小为 0

      • ?s

        文件大小非 0 (返回文件大小)

      • ?f

        文件是无格式(plain)文件

      • ?d

        文件是目录

      • ?l

        文件是符号连接

      • ?p

        文件是带名的管道(FIFO)

      • ?S

        文件是socket

      • ?b

        文件是特殊块文件

      • ?c

        文件是特殊字符文件

      • ?u

        文件中有 setuid bit

      • ?g

        文件中有 setgid bit

      • ?k

        文件中有 sticky bit

      • ?M

        返回最近更新文件时刻

      • ?A

        返回最近访问文件时刻

      • ?C

        返回文件的 inode 变更时刻

    • 带两个参数时
      • ?=

        文件1和文件2的最近更新时刻相同

      • ?>

        文件1的最近更新时刻要比文件2的新

      • ?<

        文件1的最近更新时刻要比文件2的旧

      • ?-

        文件2对文件1发出了硬连接指令

    throw(tag [, value =nil ])

    跳到使用了相同的tagcatch 块的终点(跳过方法)。若没有使用相同tag 的catch的话,就以NameError 结束线程。tag 可以是字符串或符号。value 将变为catch 的返回值。

    例:

    ret = catch(:exit) {
    throw :exit, 25
    some_process() # 决不会被执行
    10
    }
    p ret #=> 25
    trace_var(varname , hook )
    trace_var(varname ) {|newval | .... }

    注册钩子以监视对全局变量varname 所进行的赋值。varname 可以是字符串或Symbol

    这里所说的“全局变量”是指以“$”开头的变量,包括特殊变量

    调用之后,只要varname 所指的全局变量被赋值,就会计算字符串或Proc 对象hook 。若钩子是Proc对象的话,将把块参数中的值向外传递。另外,可注册多个钩子。

    若想解除跟踪的话,可以把hook 设为nil ,还可以使用untrace_var

    例:

    trace_var(:$v) {|val| puts "$v=#{val.inspect}" }
    $v = "foo" #=> $v="foo"
    $v = 1 #=> $v=1

    hooknil ,将返回hook 的数组(若是以块注册的话,将以Proc 对象返回)。除此之外,将返回nil。

    trap(signal , command )
    trap(signal ) { ... }

    ※ 在Ruby 1.8 以后的版本中,推荐使用Signal.trap

    command 注册为signal 所指的中断的处理程序。signal 可以是信号名字符串、Symbol 或信号编号。

    command 可以是字符串或块。若将其设为nil 、空字符串"""SIG_IGN" 或者"IGNORE" 时,将忽略该信号(若可能的话)。若将其设为"SIG_DFL""DEFAULT" 时,将进行默认的动作。若设为"EXIT" 时,在接到信号之后将进行结束时的相关处理 ,然后以status 0 的状态结束。

    还可以将signal 设为0或"EXIT" 等特殊值。这表示“程序结束时”。

    Ruby解释器会为一些特定的信号引发异常InterruptSignalException 。还可以使用异常处理来捕捉这些信号。

    begin
    Process.kill :QUIT, $$ # 对自己发出SIGQUIT
    rescue SignalException
    puts "rescue #$!"
    end
    # => rescue SIGQUIT

    用trap()捕捉到的信号不会引发异常。

    若注册了与信号相对应的command 时,trap将返回它(若是块的话,将被当作Proc 对象返回。若是"IGNORE"或"DEFAULT"则返回nil)。若没有注册的话则返回nil。

    ruby 1.8 特性 :在执行trap之前,若注册了"IGNORE"或"DEFAULT"的话,则返回"IGNORE"、"DEFAULT"。若注册了ruby解释器无法识别的信号处理程序时将返回nil。

    p trap(:INT, "p true")     # => nil
    p trap(:INT) { } # => "p true"
    p trap(:INT, "SIG_IGN") # => #<Proc:0x401b1328>
    p trap(:INT, "DEFAULT") # => nil
    p trap(:INT, "EXIT") # => nil
    p trap(:INT, nil) # => "EXIT"

    若指定了并不存在的信号时,将引发ArgumentError 异常。

    untrace_var(varname [, hook ])

    取消与全局变量varname 有关的钩子。若指定了hook 的话,将只会取消该钩子。若省略hook 或将其设为nil 时,将取消varname 所有的钩子。返回取消钩子的数组。

    例:

    $v = nil
    trace_var(:$v) {|val| puts "$v=#{val.inspect}" }
    $v = 'str' #=> $v="str"
    untrace_var :$v
    $v = 'str' # 不输出任何信息
    warn(mesg )

    ruby 1.8 特性

    依次输出mesg 和换行符到$stderr 之中。若内部变量$VERBOSE 为nil时,则不会输出。这等同于

    $stderr.print mesg, "/n" unless $VERBOSE.nil?

    返回nil


    展开全文
  • 1.使用线性脚本执行没有任何问题 2.将同样的代码写在方法内,调用该方法,程序执行完成后浏览器会自动关闭 a,这样写,浏览器不会关闭 ...如果将浏览器全局后,打开浏览器不在函数内部,函...
  • 常见问题:很多人使用以上方法后,经常出现的问题是代码没有任何错误,程序可以运行,就是出来的图形只有一个空坐标轴,看不到图形。 问题分析:出现这种问题的原因是图形的显示区域没设对。比如,我们上述三种...
  • 在开发中,对于任何变量、数组、函数、对象等,只要不在函数的内部,都会被默认为是全局的,意味着页面上的其他脚本都可以访问它,并可进行重写覆盖。 对于不必要放在函数内部的变量,我们要如何保证不被其他代码...
  • // 有三个方法用到了这个内部函数 // _.extend & _.extendOwn & _.defaults // _.extend = createAssigner(_.allKeys); // _.extendOwn = _.assign = createAssigner(_.keys); // _.defaults &#...
  • 对于 printf() 函数我们并不陌生,初学C语言使用的第一个函数,其作用是终端打印显示格式化字符串。 但是如果我们使用的是单片机...这里的重定向就非常复杂了,你需要懂 printf() 函数内部实现机制。。。。。(参...
  • 在函数外部方法声明的变量 没有加var关键字声明的变量(隐式全局变量) // 全局变量 可以在局部使用 var str='夜宵想吃啥?'; function fn1(){ // 函数内部,使用全局变量 console.log(str) } fn1(); 不在任何函数...
  • JS匿名函数、闭包

    2012-02-16 09:34:02
    在函数内部定义了其他函数时,就创建了闭包。闭包有权访问包含函数内部的所有变量,原理如下: 在后台执行环境中,闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域; 通常,函数的作用域...
  • javascript函数”重载”

    2019-07-17 17:36:23
    问题:js函数是没有重载的,那么有没有替代的方法实现类似重载的功能呢? 解释:在看书的时候,发现js函数的一个重要特点就是不限制传进来的参数个数,也不在乎传递进来的参数是...实际上,在函数体内可以通过argum...
  • 刚刚在洗澡的时候在想函数式编程的东西,函数式编程不是将函数看成一个对象,函数就是变量,它可以作为参数使用,它既可以作为左值来使用也可以作为右值来使用,函数式编程任何一个函数对于同一个输入,既在函数参数...
  • 所以,作为main函数,是程序的入口点,此时任何实例都没有初始化,自然要作为static来定义。 可能你的理解上有些问题,或者书上写的不对。 静态方法里面可以出现不是静态的的成员变量和方法的。 当然前提是先进性...
  • 对于Java函数的参数传递,在Java当中,只会进行数值的...因此,在函数内部,可以根据这个引用去调用对象的各种方法。 但是如果对这个引用进行修改,对原本的对象肯定是没有任何影响的。 举个例子: public class Main {
  • 若一个组件只用于展示数据,所有动态数据都从父组件传递进来(只有props),内部没有逻辑交互(无methods方法、也没有mounted等任何生命周期处理函数),没有状态修改(无data),则推荐使用函数式组件来提升vue的性能...
  • JAVA 基础 - 构造函数

    2008-07-15 15:53:00
    构造函数看起来有点奇怪,因为它没有任何返回值,即使是void型的值也不返回。这是因为一个类的构造函数内隐藏的类型是它自己类的类型。构造函数的任务就是初始化一个对象的内部状态,以便使创建的实例变量能够完全...
  • C++内部

    2021-05-08 20:31:19
    反过来,从内部类看外部类,因为内部类属于外部类的一个成员,所以对外部类的成员访问没有限制(这就跟一个类中的成员函数访问类中的任何成员变量一样没有访问权限的限制)。但是,默认情况下,内部类得不到外部类的...
  • 我们知道,当函数运行结束的时候,函数内部的局部变量就会消失,这C/C++里没有任何疑问的规定,但是今天我写代码的时候突然就想到了一个相当纠结的问题,那就是当我一个函数返回类型是一个对象的时候,以我当时...
  • '''1、绑定方法 特性:绑定给谁就应该由谁来调用,谁来调用就会将谁当作第一个参数自动传入 《《《精髓在于自动传值》》》 绑定方法分为两类: 1.1 绑定给对象方法 内部定义的函数没有任何装饰器修饰的),...
  • 我们知道,当函数运行结束的时候,函数内部的局部变量就会消失,这C/C++里没有任何疑问的规定,但是今天我写代码的时候突然就想到了一个相当纠结的问题,那就是当我一个函数返回类型是一个对象的时候,以我当时...
  • Rust中的可验证延迟功能(VDF)实现 什么是VDF?... 表单是内部表示的(a,b,c),大多数辩护中都没有使用判别式。 此实现会每次乘法和平方后执行归约,因为不这样做不会给我们的基准带来任何

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 560
精华内容 224
关键字:

在函数内部没有任何方法