Laravel中使用自己编写类库的3种方法
投稿：junjie
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Laravel中使用自己编写类库的3种方法,本文讲解了增加可直接实例化的类、增加可直接调用的函数、增加稍微复杂的类库三种方式,需要的朋友可以参考下
虽然Composer使得我们可以重用很多现有的类库（例如packagist.org中的），但是我们仍然可能用到一些不兼容composer的包或者类库。另外在某一项目中，我们也可能会创建某一类库，而且可能并没有制作成为composer package 的打算。这个时候我们可以通过以下方式来使用自己的特有类库。
增加可直接实例化的类
有些需要直接在项目中使用的类，可以通过以下方式增加到Laravel中
1.创建类库文件app/libraries/class/myClass.php
2.写入文件内容
class Message {
&&& public static function display() {
在app/start/globals.php中增加类导入路径
ClassLoader::addDirectories(array(
&&& app_path().'/commands',
&&& app_path().'/controllers',
&&& app_path().'/models',
&&& app_path().'/database/seeds',
&&& app_path().'/libaries/class', // 在这里增加
在composer.json中增加autoload目录
"autoload": {
&&& "classmap": [
&&&&&&& "app/commands",
&&&&&&& "app/controllers",
&&&&&&& "app/models",
&&&&&&& "app/database/migrations",
&&&&&&& "app/database/seeds",
&&&&&&& "app/tests/TestCase.php",
&&&&&&& "app/libraries/class"&& //在这里增加
1.执行composer dump-autoload来创建导入映射
2.使用自己导入的类直接调用Message::display()即可
这种方法同样也是增加队列类的方法，很多人不知道Laravel中队列处理类应该放在哪里，其实按照上面的方法，在app目录下创建一个queues目录，然后让其可以直接实例化即可
增加可直接调用的函数
有人喜欢用v()来代替var_dump()，想要在Laravel中这么做也非常容易
1.创建一个函数文件app/libraries/function/helper.php
2.写入文件内容
function v($msg){
&&& var_dump($msg);
把文件增加到composer自动导入列表中
"autoload": {
&& "classmap": [
&&&&&& ...
&& "files": [
&&&&&& "app/libraries/function/helper.php"
或者在项目中显示require这个文件。打开app/start/global.php，在末尾增加：
require app_path().'/libraries/function/helper.php';
个人感觉这两种方式都OK，如果想要控制这个文件加载的时间，甚至可以在filter.php文件中增加以下内容
App::before( function( $request ) {
&&& require( "{$GLOBALS['app']['path.base']}/app/libraries/function/helper.php" );
在项目中直接使用函数v('hello world');
增加稍微复杂的类库
有的时候一个类库不仅仅是一个文件那么简单，因此下面的方式更加适合有多个文件多个结构的类库。
创建psr0或者psr4标准的目录结构。
&&&&&&& Search (note directory is capitalized)
&&&&&&&&&&& Search.php
&&&&&&&&&&& SearchFacade.php
&&&&&&&&&&& SearchServiceProvider.php
&&&&&&& AnotherLib
Myapp/Search/Search.php中Search类的命名空间为Myapp\Search。
修改composer中autoload
"autoload": {
&&& "classmap": [
&&&&&&& "app/commands",
&&&&&&& "app/controllers",
&&&&&&& "app/models",
&&&&&&& "app/libraries",
&&&&&&& "app/database/migrations",
&&&&&&& "app/database/seeds",
&&&&&&& "app/tests/TestCase.php"
&&& "psr-0": {
&&&&&&&& "Myapp": "app/libraries"
在项目中使用new Myapp\Search\Search()来实例化某一类
虽然Laravel没有强制哪种方式最好，但是有一定的标准可以使得项目结构清晰，多人合作开发时省去很多交流成本。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具打赏支持，微信扫一扫。加群交流。
已有25人支持~~~
写在前面：案例、常用、归类、解释说明。（By Jim）
#!/bin/bash
# testing the script
function myfun {
echo "This is an example of a function"
while [ $count -le 5 ]
count=$[ $count +1 ]
echo "This is the end of the loop"
echo "Now this is the end of the script"
（记得空格，函数一定要在使用之前定义，函数名必须唯一）返回值可以通过$?来确定函数的退出状态使用return命令
#!/bin/bash
# testing the script
function myfun {
read -p "Enter a value:" value
echo "double the value"
return $[ $value * 2 ]
echo "The new vlue is $?"
结果：Enter a value:23double the valueThe new vlue is 46（退出状态的取值范围是0到255，$?是最近已执行命令的退出状态）使用函数输出，这种方法最靠谱了看例子
#!/bin/bash
# testing the script
function myfun {
read -p "Enter a value:" value
echo $[ $value * 2 ]
result=`myfun`
echo "The new vlue is $result"
(这样就能很好的利用输出结果了)在函数中使用变量向函数传递参数
#!/bin/bash
# testing the script
function addem {
if [ $# -eq 0 ]||[ $# -gt 2 ]
elif [ $# -eq 1 ]
echo $[ $1 + $1 ]
echo $[ $1 + $2 ]
echo -n "Adding 10 and 15:"
value=`addem 10 15`
echo $value
echo -n "Just one number 10:"
value=`addem 10`
echo $value
echo -n "No numbers:"
value=`addem`
echo $value
echo -n "More than two numbers:"
vaule=`addem 10 15 20`
echo $value
结果：Adding 10 and 15:25Just one number 10:20No numbers:-1（由上述可知，$#可以得到参数的个数，$1表示第一个参数，$2表示第二个参数）
#!/bin/bash
# testing the script
function addem {
if [ $# -eq 0 ]||[ $# -gt 2 ]
elif [ $# -eq 1 ]
echo $[ $1 + $1 ]
echo $[ $1 + $2 ]
if [ $# -eq 2 ]
value=`addem $1 $2`
echo "The value is $value"
echo "Usage:test1 a b"
（函数外面的$#表示调用脚本使用的参数数，函数里的$#表示调用函数使用的参数数，注意这点区别）作用域是变量的可见区域。全局变量，在shell脚本内处处有效的变量。函数中定义全局变量，那么主代码中有效。主代码中定义全局，函数中也有效。默认情况下，脚本中定义的变量都是全局变量。看例子：
#!/bin/bash
# testing the script
function myfun {
value=$[ $value * 2 ]
read -p "Enter a value:" value
echo "The new value is:$value"
（输入45，得到90，这里的value在函数中发生变化了，到脚本中一样可以使用，而且已经变化了）局部变量作用范围只在函数当中关键字local
#!/bin/bash
# testing the script
function myfun {
local value=$[ $value * 2 ]
read -p "Enter a value:" value
echo "The new value is:$value"
（输入45，输出45。因为加上local关键字之后，函数中的value是局部变量，与外界无关）
#!/bin/bash
# testing the script
function myfun {
local value=$[ $value * 2 ]
echo $value
read -p "Enter a value:" value
result=`myfun`
echo "The new value is:$value"
echo "The result of the fun is $result"
（不过可以通过输出来获取函数处理的结果，这里的result还是处理后的结果，比如输入45，处理后是90）数组变量与函数
#!/bin/bash
# testing the script
function addarray {
local sum=0
local newarray
newarray=(`echo "$@"`)
for value in ${newarray[*]}
sum=$[ $sum + $value ]
myarray=(1 2 3 4 5)
echo "The original array is :${myarray[*]}"
arg=`echo ${myarray[*]}`
result=`addarray $arg`
echo "The result is $result"
结果：The original array is :1 2 3 4 5The result is 15(数组参数传入函数，函数获取后，进行处理输出。脚本将输出结果打印)
#!/bin/bash
# testing the script
function addarray {
local sum=0
local newarray
newarray=(`echo "$@"`)
for value in ${newarray[*]}
sum=$[ $sum + $value ]
echo ${newarray[*]}
myarray=(1 2 3 4 5)
echo "The original array is :${myarray[*]}"
arg=`echo ${myarray[*]}`
result=`addarray $arg`
echo "The result is $result"
（输出数组）函数递归
#!/bin/bash
# testing the script
function factorial {
if [ $1 -eq 1 ]
local temp=$[ $1 -1 ]
local result=`factorial $temp`
echo $[ $result * $1 ]
read -p "Enter value:" value
result=`factorial $value`
echo "The factorial of $value is:$result"
（输入5，输出120。大环套小环，小环套更小，逐步执行。我们一步一步剖析5输入得到5*4!4又得到4*3！3又得到3*2！2又得到2*1由此得到5*4*3*2*1也就是120）显然单个脚本有助于减少输入量，但是如果多个脚本碰巧使用同样的函数又该怎样？创建库
#my script functions
function addem {
echo $[ $1 + $2 ]
function multem {
echo $[ $1 * $2 ]
function divem {
if [ $2 -ne 0 ]
echo $[ $1 / $2 ]
使用函数库的关键词是source
#!/bin/bash
# testing the script
source ./myfuncs
result=`addem 10 15`
echo "The result is $result"
（通过source就能使用库函数了）#!/bin/bash# testing the script. ./myfuncsresult=`addem 10 15`echo "The result is $result"（或者点操作符，效果是一样的）在命令行中使用函数[root@localhost shellscript]# function multem {& echo $[ $1 * $2 ]& }[root@localhost shellscript]# multem 2 510（多行命令）在.bashrc文件中定义函数直接在命令行定义shell函数的缺点是一旦退出shell，函数定义将失效。比较省事的方法是将函数定义在shell每次启动都能重新载入的地方。.bashrc文件就是这样的地方。可以用source（点操作符）将现有库文件的函数包含进.bashrc脚本。重新启动命令（source .bashrc）# .bashrc# Source global definitionsif [ -f /etc/bashrc ]; then&&&&&&& . /etc/bashrcfi# User specific aliases and functionsfunction addem {& echo $[ $1 + $2 ]}（重启之后，新加入的函数就有效了）脚本中也可以使用了
阅读(...) 评论()
“你知道你为什么还是现在这个样子吗？”“因为道理你都懂，但你懒。”Python自定义函数的创建、调用和函数的参数详解
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Python自定义函数的创建、调用和函数的参数、变量作用域等常见问题,需要的朋友可以参考下
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创见函数，这被叫做用户自定义函数。一、定义一个函数你可以定义一个由自己想要功能的函数，以下是简单的规则：
1.函数代码块以def关键词开头，后接函数标识符名称和圆括号()。2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。4.函数内容以冒号起始，并且缩进。5.Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法 代码如下:def functionname( parameters ):&& "函数_文档字符串"&& function_suite&& return [expression]默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。
以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。 代码如下:def printme( str ):&& "打印传入的字符串到标准显示设备上"&& print str&& return
二、函数调用定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数： 代码如下:#!/usr/bin/python# Function definition is heredef printme( str ):&& "打印任何传入的字符串"&&&&# Now you can call printme functionprintme("我要调用用户自定义函数!");printme("再次调用同一函数");#以上实例输出结果：
#我要调用用户自定义函数!#再次调用同一函数
三、按值传递参数和按引用传递参数所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如： 代码如下:#!/usr/bin/python# 可写函数说明def changeme( mylist ):&& "修改传入的列表"&& mylist.append([1,2,3,4]);&& print "函数内取值: ", mylist&& return# 调用changeme函数mylist = [10,20,30];changeme( mylist );print "函数外取值: ", mylist#传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
#函数内取值:& [10, 20, 30, [1, 2, 3, 4]]#函数外取值:& [10, 20, 30, [1, 2, 3, 4]]
四、函数的参数Python函数可以使用的参数类型：
1.必备参数2.命名参数3.缺省参数4.不定长参数
1、必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用printme()函数，你必须传入一个参数，不然会出现语法错误： 代码如下:#!/usr/bin/python#可写函数说明def printme( str ):&& "打印任何传入的字符串"&&&&#调用printme函数printme();#以上实例输出结果：
#Traceback (most recent call last):#& File "test.py", line 11, in &module&#&&& printme();#TypeError: printme() takes exactly 1 argument (0 given)
2、命名参数
命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。你可以跳过不传的参数或者乱序传参，因为Python解释器能够用参数名匹配参数值。用命名参数调用printme()函数： 代码如下:#!/usr/bin/python#可写函数说明def printme( str ):&& "打印任何传入的字符串"&&&&#调用printme函数printme( str = "My string");#以上实例输出结果：
#My string下例能将命名参数顺序不重要展示得更清楚： 代码如下:#!/usr/bin/python#可写函数说明def printinfo( name, age ):&& "打印任何传入的字符串"&& print "Name: ",&& print "Age ",&&#调用printinfo函数printinfo( age=50, name="miki" );#以上实例输出结果：
#Name:& miki#Age& 50
3、缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入： 代码如下:#!/usr/bin/python#可写函数说明def printinfo( name, age = 35 ):&& "打印任何传入的字符串"&& print "Name: ",&& print "Age ",&&#调用printinfo函数printinfo( age=50, name="miki" );printinfo( name="miki" );#以上实例输出结果：
#Name:& miki#Age& 50#Name:& miki#Age& 35
4、不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下： 代码如下:def functionname([formal_args,] *var_args_tuple ):&& "函数_文档字符串"&& function_suite&& return [expression]加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例： 代码如下:#!/usr/bin/python# 可写函数说明def printinfo( arg1, *vartuple ):&& "打印任何传入的参数"&& print "输出: "&& print arg1&& for var in vartuple:&&&&& print var&&# 调用printinfo 函数printinfo( 10 );printinfo( 70, 60, 50 );#以上实例输出结果：
#输出:#10#输出:#70#60#50
五、匿名函数用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
Lambda函数能接收任何数量的参数但只能返回一个表达式的值，同时只能不能包含命令或多个表达式。匿名函数不能直接调用print，因为lambda需要一个表达式。lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数。虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。语法
lambda函数的语法只包含一个语句，如下： 代码如下:lambda [arg1 [,arg2,.....argn]]:expression如下实例： 代码如下:#!/usr/bin/python#可写函数说明sum = lambda arg1, arg2: arg1 + arg2;#调用sum函数print "Value of total : ", sum( 10, 20 )print "Value of total : ", sum( 20, 20 )#以上实例输出结果：
#Value of total :& 30#Value of total :& 40
六、关于return语句return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做： 代码如下:#!/usr/bin/python# 可写函数说明def sum( arg1, arg2 ):&& # 返回2个参数的和."&& total = arg1 + arg2&& print "Inside the function : ", total&&# 调用sum函数total = sum( 10, 20 );print "Outside the function : ", total #以上实例输出结果：
#Inside the function :& 30#Outside the function :& 30
七、变量作用域一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：1.全局变量2.局部变量
八、变量和局部变量定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例： 代码如下:#!/usr/bin/pythontotal = 0; # This is global variable.# 可写函数说明def sum( arg1, arg2 ):&& #返回2个参数的和."&& total = arg1 + arg2; # total在这里是局部变量.&& print "Inside the function local total : ", total&&#调用sum函数sum( 10, 20 );print "Outside the function global total : ", total #以上实例输出结果：
#Inside the function local total :& 30#Outside the function global total :& 0
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具