澳门新葡萄京官网注册PHP解密Unicode及Escape加密字符串

本文给大家分享一个PHP解密Unicode及Escape加密字符串函数

bytes包提供了对字节切片进行读写操作的一系列函数
字节切片处理的函数比較多,分为基本处理函数,比較函数,后缀检查函数,索引函数,切割函数,
大写和小写处理函数和子切片处理函数等.

大家好,我是IT修真院萌新分院的张晓琳,一枚正直、纯洁、善良的前端程序员。

>6);  
     $str.=chr(0x80 | $c & 0x3f);  
  } else if ($c < 0x10000) {  
     $str.=chr(0xe0 | $c>>12);  
     $str.=chr(0x80 | $c>>6 & 0x3f);  
     $str.=chr(0x80 | $c & 0x3f);  
  } else if ($c < 0x200000) {  
     $str.=chr(0xf0 | $c>>18);  
     $str.=chr(0x80 | $c>>12 & 0x3f);  
     $str.=chr(0x80 | $c>>6 & 0x3f);  
     $str.=chr(0x80 | $c & 0x3f);  
  }  
  return $str;  
}  

$str='%u5927%u5BB6%u597D%uFF0C我是孤魂!
u8FD9u662Fu6D4Bu8BD5u6587u672CuFF01';  
echo uni_decode($str); // 大家好,我是孤魂!这是测试文本!  

1.字节切片基本处理函数api

今天给大家分享一下,修真院官网任务js-task6,深度思考的知识点——函数声明与函数表达式的区别?.

在网上搜索一把,很多用php实现的escape函数,大同小异

1.1Contains()函数

//Contains()函数的功能是检查字节切片b是否包括子切片subslice,假设包括返回true,否则返回false.
func Contains(b,subslice []bytes) bool

1.背景介绍

function phpescape($str){ 
  preg_match_all("/[x80-xff].|[x01-x7f]+/",$str,$newstr); 
  $ar = $newstr[0]; 
  foreach($ar as $k=>$v){ 
    if(ord($ar[$k])>=127){ 
      $tmpString=bin2hex(iconv("GBK","ucs-2",$v)); 
      if (!eregi("WIN",PHP_OS)){ 
        $tmpString = substr($tmpString,2,2).substr($tmpString,0,2); 
      } 
      $reString.="%u".$tmpString; 
    } else { 
      $reString.= rawurlencode($v); 
    } 
  } 
  return $reString; 
} 

1.2Count()函数

//Count()函数的功能是计算字节切片sep在字节切片s中非重叠显示的个数.
func Count(s,sep[]byte) int

什么是函数声明?

以上所述就是本文的全部内容了,希望大家能够喜欢。

1.3Repeat()函数

//Repeat()函数的功能是把切片b复制count个,然后合成一个新的字节切片返回.
func Repeat(b[]byte,count int) []byte

函数声明可以定义命名的函数变量,而无需给变量赋值。函数声明是一种独立的结构,不能嵌套在非功能模块中。可以将它类比为
变量声明。就像变量声明必须以“var”开头一样,变量声明必须以“function”开头。函数名在自身作用域和父作用域内是可获取的(否则就取不到函数了)。

1.4Replace()函数

/*Replace()函数的功能是返回字节切片s的一个副本,并把前n个不重叠的
子切片old替换为new;假设n<0,则不限制替换的数量.參数n为替换的次数*/
func Replace(s,old,new []byte,n int) []byte

什么是函数表达式?

1.5Runes()函数

//Runes()函数的功能是把s转换为UTF-8编码的字节序列,并返回相应的Unicode切片.
func Runes(s []byte) []rune

函数表达式将函数定义为表达式语句(通常是变量赋值)的一部分。通过函数表达式定义的函数可以是命名的,也可以是匿名的。函数表达式不能以“function”开头(下面自调用的例子要用括号将其括起来)。函数名(如果有的话)在作用域外是不可获取的(与
Function Declaration 对比)。

1.6Join()函数

Join函数的功能是用字节切片sep把s中的每一个字节切片连成一个字节切片并返回.
func Join(s [][]byte,sep[]byte) []byte

2.知识剖析

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Contains
    b := []byte("mChenys") //字符串强转为byte切片
    sublice1 := []byte("m")
    sublice2 := []byte("M")
    fmt.Println(bytes.Contains(b,sublice1))//true
    fmt.Println(bytes.Contains(b,sublice2))//false

    //Count
    s := []byte("hahaahaaa")
    sep1 := []byte("hah")
    sep2 := []byte("aa")
    sep3 := []byte("a")
    fmt.Println(bytes.Count(s,sep1))//1
    fmt.Println(bytes.Count(s,sep2))//2
    fmt.Println(bytes.Count(s,sep3))//6

    //Repeat
    b = []byte("ha")
    fmt.Println(string(bytes.Repeat(b,1)))//ha
    fmt.Println(string(bytes.Repeat(b,2)))//haha

    //Replace
    s = []byte("hello,world")
    old := []byte("o")
    news := []byte("ee")
    fmt.Println(string(bytes.Replace(s,old,news,0)))//hello,world
    fmt.Println(string(bytes.Replace(s,old,news,1)))//hellee,world
    fmt.Println(string(bytes.Replace(s,old,news,2)))//hellee,weerld
    fmt.Println(string(bytes.Replace(s,old,news,-1)))//hellee,weerld

    //Runes
    s = []byte("你好世界")
    r := bytes.Runes(s)
    fmt.Println("转换前字符串的长度: ",len(s))//12
    fmt.Println("转换后字符串的长度: ",len(r))//4

    //Join
    s := [][]byte{[]byte("你好"),[]byte("世界")}
    sep1 := []byte(",")
    fmt.Println(string(bytes.Join(s,sep1)))//你好,世界
    sep2 := []byte("#")
    fmt.Println(string(bytes.Join(s,sep2)))//你好#世界
}

Javascript
Function无处不在,而且功能强大!通过Javascript函数可以让JS具有面向对象的一些特征,实现封装、继承等,也可以让代码得到复用。但事物都有两面性,Javascript函数有的时候也比较“任性”,你如果不了解它的“性情”,它很可能给你制造出一些意想不到的麻烦(bugs)出来。
  Javascript Function有两种类型:

2.字节切片比較函数

// 函数声明

2.1Compare()函数

/*Compare()函数的功能是依据字节的值比較字节切片a和b的大小,假设a=b,返回0,
假设a>b返回1,假设a<b返回-1.*/
func Compare(a,b[]byte) int

function funDeclaration(type){

2.2Equal()函数

/*Equal()函数的功能是用来比較2个字节切片是否相等,假设參数为nil,则等同于
空的字节切片,假设a=b,则返回true,否则返回false.区分大写和小写*/
func Equal(a,b[]byte) bool

2.3EqualFold()函数

/*EqualFold()函数的功能是把s和t转换成UTF-8字符串进行比較,
而且忽略大写和小写,假设s=t,返回true,否则,返回false.*/
func EqualFold(s,t[]byte) bool

return type===”Declaration”;

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Compare
    a := []byte("abc")
    b := []byte("a")
    fmt.Println(bytes.Compare(a,b))//1 
    b =[]byte("abcd")
    fmt.Println(bytes.Compare(a,b))//-1
    b =[]byte("abC")
    fmt.Println(bytes.Compare(a,b))//1  小写字母大于大写字母
    b =[]byte("b")
    fmt.Println(bytes.Compare(a,b))//-1 从第一个字节開始比較,假设同样再比較长度

    //Equal
    a = []byte("abc")
    b = []byte("ABC")
    fmt.Println(bytes.Equal(a,b))//false
    fmt.Println(bytes.Equal(a,nil))//false
    b = []byte("abc")
    fmt.Println(bytes.Equal(a,b))//true

    //EqualFold
    a = []byte("abc")
    b = []byte("ABC")
    fmt.Println(bytes.EqualFold(a,b))//true

}

}

3.字节切片前后缀检查

// 函数表达式

3.1HasPrefix()函数

//HasPrefix()函数的功能是检查字节切片s的前缀是否为prefix,假设是返回true,假设不是返回false.
func HasPrefix(s,prefix[]byte) bool

var funExpression = function(type){

3.2HashSuffix()函数

//HashSuffix()函数的功能是检查字节切片s的后缀是否为suffix,假设是返回true,否则返回false.
func HashSuffix(s,suffix[]byte) bool

return type===”Expression”;

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //HasPrefix
    s := []byte("mChenys")
    prefix := []byte("m")
    fmt.Println(bytes.HasPrefix(s,prefix))//true
    prefix = []byte("men")
    fmt.Println(bytes.HasPrefix(s,prefix))//false

    //HashSuffix
    suffix := []byte("ys")
    fmt.Println(bytes.HasSuffix(s,suffix))//true

}

}

4.字节切片位置索引函数

字节切片位置索引函数共同拥有8个,Index(),IndexAny(),IndexByte(),IndexFunc(),IndexRune(),
LastIndex(),LastIndexAny()和LastIndexFunc().

3.常见问题

4.1index()函数

//返回sep在s中第一次出现的位置索引(从0開始),假设sep中不在s中则返回-1.
func Index(s,sep []byte) int

两者之间有什么区别?

4.2IndexAny()函数

/*把s解析为UTF-8编码的字节序列,返回chars中不论什么一个字符在s中第一次
出现的索引位置;假设s中不包括chars中不论什么一个字符,则返回-1.*/
func IndexAny(s []byte,chars string) int

4.解决方案

4.3IndexByte()函数

//函数的功能是检查字节c在s中第一次出现的位置索引;假设s中不包括c则返回-1.
func IndexByte(s[]byte,c byte) int

一、函数声明中函数名是必须的;函数表达式中则是可选的

4.4IndexFunc()函数

/*的功能是把s解析为UTF-8字节序列,并返回一个满足f(c)=true的字符c的位置
索引,假设没有满足则返回-1.*/
func IndexFunc(s[]byte,f func(r rune)bool) int

//函数表达式

4.5IndexRune()函数

/*功能是把s解析为UTF-8字节序列,并返回rune类型的字符r在s中的位置索引,
假设s中不包括r则返回-1.*/
func IndexRune(s[]byte,r rune) int

var s = function sum(a, b) {

4.6LastIndex()函数

//的功能是返回sep在s中最后一次出现的位置索引,假设s中不包括sep,则返回-1
func LastIndex(s,sep[]byte) int

return a + b;

4.7LastIndexAny()函数

/*的功能是把s解析为UTF-8字节序列,返回chars中不论什么一个字符在s中最后
出现的位置索引,假设chars为空或者s中不包括chars中的随意字符,则返回-1*/
func LastIndexAny(s[]byte,chars string) int

}

4.8LastIndexFunc()函数

/*功能是把s解析成UTF-8字节序列,返回满足f(s)=true的字符c在s中最后
一次出现的位置索引,假设没有找到则返回-1.*/
func LastIndexFunc(s[]byte,f func(r rune)bool) int

alert(s(1, 2));

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Index
    a := []byte("aaaaa")
    fmt.Println(bytes.Index(a,[]byte("a")))//0
    fmt.Println(bytes.Index(a,[]byte("aa")))//0
    fmt.Println(bytes.Index(a,[]byte("b")))//-1

    //IndexAny
    fmt.Println(bytes.IndexAny(a,"a"))//0
    fmt.Println(bytes.IndexAny(a,"aa"))//0

    //IndexByte
    s := []byte("google")
    var ch byte = 'g'
    fmt.Println(bytes.IndexByte(s,ch))//0

    //IndexFunc,能够接收匿名函数
    fmt.Println(bytes.IndexFunc(s,func (a rune)bool{
        if a == 'o'{
            return true
        }else{
            return false
        }
    }))//1

    //IndexRune
    fmt.Println(bytes.IndexRune(s,'e'))//5
    fmt.Println(bytes.IndexRune(s,'a'))//-1

    //LastIndex
    fmt.Println(bytes.LastIndex(s,[]byte("g")))//3
    fmt.Println(bytes.LastIndex(s,[]byte("e")))//5
    fmt.Println(bytes.LastIndex(s,[]byte("o")))//2

    //LastIndexAny
    fmt.Println(bytes.LastIndexAny(s,"gle"))//5
    fmt.Println(bytes.LastIndexAny(s,"l"))//4
    fmt.Println(bytes.LastIndexAny(s,"ge"))//5

    //LastIndexFunc
    fmt.Println(bytes.LastIndexFunc(s,func(r rune)bool{
        if r=='g'{
            return true
        }else {
            return false
        }
    }))//3
}

var s = function(a, b) {

5.字节切片切割函数

字节切片切割函数共同拥有6个,Fields(),FieldsFunc(),Split(),SplitN(),
SplitAfter()和SplitAfterN()

return a + b;

5.1Fields()函数

/*功能是把字节切片s依照一个或者连续多个空白字符切割成多个字节切片,
假设s仅仅包括空白字符则返回空字节切片,当中參数s准备切割的字节切片.*/
func Fields(s[]byte) [][]byte wq

}

5.2FieldsFunc()函数

/*功能是把s解析为UTF-8字节序列,对于每一个Unicode字符c,假设f(c)
返回true就把c作为切割字符对s进行拆分.假设全部字符都满足f(c)为true,则返回空切片.*/
func FieldsFunc(s []byte,f func(r rune)bool) [][]byte

alert(s(1, 2));

5.3Split()函数

/*功能是把s用sep切割成多个字节切片并返回,假设sep为空,Split则把s切分成
每一个字节切片相应一个UTF-8字符,Split()等效于參数为n的splitN()函数.*/
func Split(s,sep[]byte)[][]byte

//以上两种都可以

5.4SplitAfter()函数

/*功能使用sep作为后缀把s切分成多个字节切片并返回。假设sep为空,
则把s切分成每一个字节切片相应一个UTF-8字符*/
func SplitAfter(s,sep[]byte)[][]byte

//函数声明

5.5SplitAfterN()函数

/*功能是用sep作为后缀把s切分成多个字节切片并返回。假设sep为空。则把s切分成每一个字节切片
相应一个UTF-8字符。參数n决定返回切片的长度:假设n>0,最多返回n个子字节切片,
子切片可能包括未切分的字节序列;假设n=0。返回空切片假设n< 0返回全部子切片。*/
func SplitAfterN(s,sep[]byte,n int)[][]byte

function sum(a, b) {

5.6SplitN()函数

/*功能是把s用sep切割成多个字节切片并返回,假设sep为空,Split则把s
切分成每一个字节切片相应一个UTF-8字符,參数n决定返回长度,n>0最多返回那个子切片;
n==0什么都不返回,n<0返回空子切片.*/
func SplitN(s,sep []byte,n int)[][]byte

return a + b;

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Fields ,返回的是2维切片
    s := []byte("a b   c")
    for _,v := range bytes.Fields(s){ 
        //遍历获取1维切片,再强转为字符串
        fmt.Print(string(v)+",") //a,b,c,
    }

    //FieldsFunc,返回是2维切片,接收匿名函数
    for _,v := range bytes.FieldsFunc(s,func(r rune)bool{
        if r == ' '{
            return true //依照空白字符切割
        }else{
            return false
        }
    }){
        fmt.Print(string(v)+",")//a,b,c,
    }

    //Split
    s = []byte("吃饭和睡觉")
    for _,v := range bytes.Split(s,[]byte("和")){
        fmt.Print(string(v)+",")//吃饭,睡觉,
    }
    for _,v := range bytes.Split(s,nil){
        fmt.Print(string(v)+",")//吃,饭,和,睡,觉,
    }

    //SplitAfter
    s = []byte("abbcbbd")
    for _,v := range bytes.SplitAfter(s,[]byte("bb")){
        fmt.Print(string(v)+",")//abb,cbb,d,
    }
    for _,v := range bytes.SplitAfter(s,nil){
        fmt.Print(string(v)+",")//a,b,b,c,b,b,d,
    }

    //SplitAfterN
    s = []byte("hehehe")
    for _,v := range bytes.SplitAfterN(s,[]byte("he"),0){
        fmt.Print(string(v)+",") //什么都不输出
    }
    for _,v := range bytes.SplitAfterN(s,[]byte("he"),1){
        fmt.Print(string(v)+",")//hehehe,
    }
    for _,v := range bytes.SplitAfterN(s,[]byte("he"),-1){
        fmt.Print(string(v)+",")//he,he,he,,
    }

    //SplitN
    s = []byte("hahaha")
    for _,v := range bytes.SplitN(s,[]byte("ha"),0){
        fmt.Print(string(v)+",") //什么都不输出
    }
    for _,v := range bytes.SplitN(s,[]byte("ha"),1){
        fmt.Print(string(v)+",")//hahaha,
    }
    for _,v := range bytes.SplitN(s,[]byte("ha"),-1){
        fmt.Print(string(v)+",")//,,,,
    }
}

}

6.字节切片大写和小写处理

共同拥有7个函数,Title(),ToTitle(),ToTitleSpecial(),ToLower(),ToLowerSpecial(),ToUpper()
和ToUpperSpecial().

alert(sum(1, 2));

6.1Title()函数

//的功能是返回一个s的副本,把s中每一个单词的首字母改成Unicode字符大写.
func Title(s[]byte) []byte

二、用函数声明定义的函数,函数可以在函数声明之前调用,而用函数表达式定义的函数只能在声明之后调用。

6.2ToTitle()函数

//的功能是返回s的一个副本,并把当中全部Unicode字符转为大写.
func ToTitle(s []byte) []byte

//函数声明

6.3ToTitleSpecial()函数

/*功能是返回s的一个副本,并把当中全部Unicode字符依据_case指定
的规则转成大写.*/
func ToTitleSpecial(_case unicode.SpecialCase,s []byte) []byte

alert(sum(1, 2));//3

6.4ToLower()函数

//的功能是返回s的一个副本,并把当中的全部Unicode字符转为小写.
func ToLower(s []byte)[]byte

function sum(a, b) {

6.5ToLowerSpecial()函数

/*功能是返回s的一个副本,并把当中全部Unicode字符都依据_case
指定的规则转换成小写.*/
func ToLowerSpecial(_case unicode.SpecialCase, s []byte) []byte 

return a + b;

6.6ToUpper()函数

//是返回s的一个副本,并把当中全部Unicode字符都转为大写.
func ToUpper(s []byte) []byte 

}

6.7ToUpperSpecial()函数

/*的功能是返回s的一个副本,并把当中全部Unicode字符都依据_case
指定的规则转成大写.*/
func ToUpperSpecial(_case unicode.SpecialCase, s []byte) []byte

package main

import(
    "fmt"
    "bytes"
    "unicode"
)
func main(){
    s := []byte("abc")
    fmt.Println(string(bytes.Title(s)))//Abc
    fmt.Println(string(bytes.ToTitle(s)))//ABC
    fmt.Println(string(bytes.ToTitleSpecial(unicode.AzeriCase,s)))//ABC
    s = []byte("ABC")
    fmt.Println(string(bytes.ToLower(s)))//abc
    fmt.Println(string(bytes.ToLowerSpecial(unicode.AzeriCase,s)))//abc
    s = []byte("abc")
    fmt.Println(string(bytes.ToUpper(s)))//ABC
    fmt.Println(string(bytes.ToUpperSpecial(unicode.AzeriCase,s)))//ABC

}

//函数表达式:发生错误

7.子字节切片处理函数

共同拥有9个,Trim(),TrimFunc(),TrimLeft(),TrimLeftFunc(),TrimRight(),TrimRightFunc(),
TrimSpace(),TrimPrefix()和TrimSuffix().

try {

7.1Trim()函数

/*的功能是返回s的子字节切片,cutset中随意出如今s的首部和尾部的
连续字符将被删除。*/
func Trim(s []byte, cutset string) []byte 

alert(s(1, 2));

7.2TrimFunc()函数

//功能是返回s的子字节切片,删除s首部和尾部连接的满足f(c)=true的字符c。
func TrimFunc(s []byte, f func(r rune) bool) []byte 

var s = function sum(a, b) {

7.3TrimLeft()函数

//的功能是返回s的子字节切片,cutset中随意出如今s首部的连续字符被删除。
func TrimLeft(s []byte, cutset string) []byte 

return a + b;

7.4TrimLeftFunc()函数

//功能是返回s的一个子字节切片、删除s首部连续满足f(c)=true的字符c。
func TrimLeftFunc(s []byte, f func(r rune) bool) []byte  

}

7.5TrimRight()函数

//的功能是返回s的子字节切片,cutset中随意出如今s尾部的连续字符被删除。
func TrimRight(s []byte, cutset string) []byte 

}

7.6TrimRightFunc()函数

//功能是返回s的一个子字节切片、删除s尾部连续满足f(c)=true的字符c
func TrimRightFunc(s []byte, f func(r rune) bool) []byte 

catch (e) {

7.7TrimSpace()函数

/*功能是返回s的一个子字节切片。并删除s中開始和结尾处的连续的
Unicode空白字符。*/
func TrimSpace(s []byte) []byte 

alert(“wrong!”);

7.8TrimPrefix()函数

//功能是返回s的一个子字节切片,并删除前缀为prefix的部分
func TrimPrefix(s, prefix []byte) []byte

}

7.9TrimSuffix()函数

//功能是返回s的一个子字节切片,并删除后缀为suffix的部分
func TrimSuffix(s, suffix []byte) []byte

5.编码实战

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Trim
    s := []byte(" abc   ")
    fmt.Println(string(bytes.Trim(s," "))+"d")//abcd

    //TrimFunc
    s = []byte("hello world")
    fmt.Println(string(bytes.TrimFunc(s,func(r rune)bool{
        if r=='h' || r=='d'{
            return true
        }else{
            return false
        }
    }))) //ello worl


    s = []byte("helloh")
    fmt.Println(string(bytes.TrimFunc(s,func(r rune)bool{
        if r=='h' || r=='o'{
            return true
        }else{
            return false
        }
    }))) //ell

    s = []byte("helloh")
    fmt.Println(string(bytes.TrimFunc(s,func(r rune)bool{
        if r=='h' && r=='o'{
            return true
        }else{
            return false
        }
    }))) //helloh

    //TrimLeft
    fmt.Println(string(bytes.TrimLeft(s,"h")))//elloh
    fmt.Println(string(bytes.TrimLeft(s,"l")))//helloh

    //TrimLeftFunc
    fmt.Println(string(bytes.TrimLeftFunc(s,func(r rune)bool{
        if r == 'h' || r=='l'{
            return true
        }else{
            return false
        }

    }))) //elloh

    //TrimRight
    fmt.Println(string(bytes.TrimRight(s,"oh")))//hell

    //TrimRightFunc
    fmt.Println(string(bytes.TrimRightFunc(s,func(r rune)bool{
        if r == 'h'{
            return true
        }else{
            return false
        }

    })))//hello

    //TrimSpace
    s = []byte("  abc   ")
    fmt.Println("d"+string(bytes.TrimSpace(s))+"d")//dabcd

    //TrimPrefix
    s = []byte("mChenys")
    fmt.Println(string(bytes.TrimPrefix(s,[]byte("mC"))))//henys
    fmt.Println(string(bytes.TrimPrefix(s,[]byte("en"))))//mChenys

    //TrimSuffix
    s = []byte("mChenys")
    fmt.Println(string(bytes.TrimSuffix(s,[]byte("ys"))))//mChen
    fmt.Println(string(bytes.TrimSuffix(s,[]byte("en"))))//mChenys
}

6.扩展思考

使用function关键字声明一个函数,再指定一个函数名,叫函数声明。

function fn(){……}

使用function关键字声明一个函数,但未给函数命名,最后将匿名函数赋予一个变量,叫函数表达式。

var fn=function(){……}

使用function关键字声明一个函数,但未给函数命名,这个又称之为什么呢?是属于以上两钟类型的哪一种?

function(){……}

匿名函数属于函数表达式,匿名函数有很多作用,赋予一个变量则创建函数,赋予一个事件则成为事件处理程序或创建闭包等等.

7.参考文献

参考一:函数声明与函数表达式以及立即执行函数的讨论

参考二:函数申明与函数表达式的区别

参考三:雨落川下雪

参考四:详解Javascript
函数声明和函数表达式的区别

8.更多讨论

1.函数声明和函数表达式的区别到底是什么?

:myFunctionDeclaration
是一个包含其它函数声明(innerFunction)的函数声明

函数表达式总是其它JavaScript语句的一部分:

var myFunc = function(){};

或者其他函数的参数:

myFunc(function() {

return function(){};

});

或者立即执行函数:

(function namedFunctionExpression () { })();

或者被为运算符修饰:

+function(){}();

2. 那么对于何为声明,何为函数表达式呢?

:建函数的最常用的两个方法是函数表达式和函数声明,两者期间的区别是有点晕,因为ECMA规范只明确了一点:函数声明必须带有标示符(Identifier)(就是大家常说的函数名称),而函数表达式则可以省略这个标示符:

函数声明:

function 函数名称 (参数:可选){ 函数体 }

函数表达式:

function 函数名称(可选)(参数:可选){ 函数体 }

3. 函数声明与函数表达式除了以代码放的位置不同区别,还有哪些不同?

:函数声明必须有函数名,而函数表达式的函数名可以省略。

函数声明必须有函数名是因为函数被调用的基本要求,在调用一个函数时我们必须能够引用它,而唯一的方法就是通过函数名。

函数表达式是其它JavaScript语句的一部分,所以我们有别的方式引用它们,比如函数被赋值给一个变量,可以通过变量名来访问:

var doNothing = function(){};

doNothing();

或者作为其它函数的参数,可以通过参数名访问:

function doSomething(action) {

action();}

关于立即执行函数的讨论

也就是说只有函数表达式才能实现立即执行,匿名函数也是函数表达式为何不能立即执行呢,因为匿名函数开始的function会被JavaScript引擎识别为函数声明的开始,所以加上括号也不会被执行了,而加上(),!,+,-等符号为什么就可以了呢,因为加上这些符号就可以告诉JavaScript引擎这不是函数声明了,就这么简单。

ppt

视频

发表评论

电子邮件地址不会被公开。 必填项已用*标注