• 最近项目不算紧,于是就学了学 Swift ,看了一大神写的项目https://github.com/hrscy/DanTang,很受益,感谢开源!...学习网站:苹果官方为开发者提供的 Swift 学习资源: https://developer.apple.com/swift/res

    最近项目不算紧,于是就学了学 Swift ,看了一大神写的项目https://github.com/hrscy/DanTang,很受益,感谢开源!另外自己也写了一些基础代码,分享出来,第一是希望得到同行前辈的指导,第二是希望对需要的朋友有所帮助。

    先分享一些学习资料:




    练习的 demo 地址: https://github.com/liuzhongning/NNMintFurniture

    • 主要包括以下功能:
      • 图片轮播
      • 导航栏渐变
      • 瀑布流练习
      • UIScrollView 练习
      • 照相功能,更换头像
      • 二维码扫描及识别
      • 随机图片验证码封装
      • 圆形输入框封装
      • 第三方库 SnapKit 用法
      • …………




    练习 demo 的简单介绍,前方高能预警,大量图片请注意手机流量!

    一、图片轮播

    图片轮播

    • 核心代码:

    轮播图的封装

        // MARK: - 懒加载轮播视图
        private lazy var shufflingFigureView : NNShufflingFigureView = {
            let frame = CGRect(x: 0, y: 0, width: NNScreenWidth, height: 180)
            let imageView = ["shuffling1", "shuffling2", "shuffling3", "shuffling4"]
            let shufflingFigureView = NNShufflingFigureView(frame: frame, images: imageView as NSArray, autoPlay: true, delay: 3, isFromNet: false)
            shufflingFigureView.delegate = self
            return shufflingFigureView
        }()

    通过代理处理图片的点击事件

    // MARK: - 轮播代理方法,处理轮播图的点击事件
    extension NNItemTableViewController: NNShufflingFigureViewDelegate {
        func addShufflingFigureView(addShufflingFigureView: NNShufflingFigureView, iconClick index: NSInteger) {
            print(index)
        }
    }

    二、导航栏渐变

    导航栏渐变

    • 核心代码

    页面滚动时调用

    // MARK: - UIScrollViewDelegate 滚动页面时调用
    extension NNItemTableViewController {
        override func scrollViewDidScroll(_ scrollView: UIScrollView) {
            if type == tableViewType.haveHeader {
                return
            }
            currentPostion = scrollView.contentOffset.y
            if currentPostion > 0 {
                if currentPostion - lastPosition >= 0 {
                    if topBool {
                        topBool = false
                        bottomBool = true
                        stopPosition = currentPostion + 64
                    }
                    lastPosition = currentPostion
                    navigationController?.navigationBar.alpha = 1 - currentPostion / 500
                } else {
                    if bottomBool {
                        bottomBool = false
                        topBool = true
                        stopPosition = currentPostion + 64
                    }
                    lastPosition = currentPostion
                    navigationController?.navigationBar.alpha = (stopPosition - currentPostion) / 200
                }
            }
        }
    }

    三、瀑布流练习

    瀑布流练习

    • 核心代码

    基础设置

            // 布局
            let layout = NNItemCollectionViewFlowLayout()
            // 创建collectionView
            let collectionView = UICollectionView.init(frame: view.bounds, collectionViewLayout: layout)
            view.addSubview(collectionView)
            collectionView.dataSource = self
            collectionView.delegate = self
            collectionView.backgroundColor = UIColor.white
            collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: NNItemCollectionViewControllerID)

    自定义 UICollectionViewFlowLayout

        // MARK: - 更新布局
        override func prepare() {
            super.prepare()
            // 清除所有的布局属性
            attrsArray.removeAll()
            columnHeightsAry.removeAll()
    
            for _ in 0 ..< columnCountDefault {
                columnHeightsAry.append(edgeInsetsDefault.top)
            }
    
            let sections : Int = (collectionView?.numberOfSections)!
            for num in 0 ..< sections {
                let count : Int = (collectionView?.numberOfItems(inSection: num))!
                for i in 0 ..< count {
                    let indexpath : NSIndexPath = NSIndexPath.init(item: i, section: num)
                    let attrs = layoutAttributesForItem(at: indexpath as IndexPath)!
                    attrsArray.append(attrs)
                }
            }
        }
    
        // MARK: - cell 对应的布局属性
        override func layoutAttributesForItem(at indexPath: IndexPath) -> UICollectionViewLayoutAttributes? {
    
            let attrs = UICollectionViewLayoutAttributes.init(forCellWith: indexPath)
            let collectionWidth = collectionView?.frame.size.width
            // 获得所有 item 的宽度
            let itemW = (collectionWidth! - edgeInsetsDefault.left - edgeInsetsDefault.right - CGFloat(columnCountDefault-1) * columnMargin) / CGFloat(columnCountDefault)
            let itemH = 50 + arc4random_uniform(100)
    
            // 找出高度最短那一列
            var dextColum : Int = 0
            var minH = columnHeightsAry[0]
            for i in 1 ..< columnCountDefault{
                // 取出第 i 列的高度
                let columnH = columnHeightsAry[i]
    
                if minH > columnH {
                    minH = columnH
                    dextColum = i
                }
            }
    
            let x = edgeInsetsDefault.left + CGFloat(dextColum) * (itemW + columnMargin)
            var y = minH
            if y != edgeInsetsDefault.top{
                y = y + itemMargin
            }
            attrs.frame = CGRect(x: x, y: y, width: itemW, height: CGFloat(itemH))
            // 更新最短那列高度
            columnHeightsAry[dextColum] = attrs.frame.maxY
            return attrs
        }

    四、UIScrollView 练习

    UIScrollView 练习

    • 核心代码
        // MARK: - 放大缩小
        // MARK: 放大
        func amplificationBtnClick() {
            var zoomScale = scrollView.zoomScale // 当前缩放
            zoomScale += 0.1
            if zoomScale >= scrollView.maximumZoomScale {
                return
            }
            self.scrollView.setZoomScale(zoomScale, animated: true)
        }
    
        // MARK: 缩小
        func narrowDownBtnClick() {
            var zoomScale = scrollView.zoomScale // 当前缩放
            zoomScale -= 0.1
            if zoomScale <= scrollView.minimumZoomScale {
                return
            }
            self.scrollView.setZoomScale(zoomScale, animated: true)
        }
    
    // MARK: - NNItemBtnViewDelegate 上下左右点击代理
    extension NNItemScrollView {
        // MARK: 向左
        func leftBtnClickDelegate() {
            var point = self.scrollView.contentOffset
            point.x += 100
            point.x = point.x >= self.scrollView.contentSize.width ? 0 : point.x
            scrollView.setContentOffset(point, animated: true)
        }
    
        // MARK: 向右
        func rightBtnClickDelegate() {
            var point = self.scrollView.contentOffset
            point.x -= 100
            point.x = point.x <= -NNScreenWidth ? 0 : point.x
            scrollView.setContentOffset(point, animated: true)
        }
    
        // MARK: 向上
        func topBtnClickDelegate() {
            var point = self.scrollView.contentOffset
            point.y += 50
            point.y = point.y >= self.scrollView.contentSize.height ? 0 : point.y
            scrollView.setContentOffset(point, animated: true)
        }
    
        // MARK: 向下
        func bottomBtnClickDelegate() {
            var point = self.scrollView.contentOffset
            point.y -= 50
            point.y = point.y <= -NNScreenHeight ? 0 : point.y
            scrollView.setContentOffset(point, animated: true)
        }
    }

    五、照相功能,更换头像(建议用真机)

    照相功能,更换头像

    • 核心代码
    // MARK: - 点击头像按钮,更换头像
        func changePicture() {
            let alertcontroller = UIAlertController(title: "请选择相片", message: nil, preferredStyle: .actionSheet)
            let alertaction = UIAlertAction(title: "从相册选取", style: .destructive) { (action) in
                let imagePicker = UIImagePickerController()
                imagePicker.delegate = self
                imagePicker.sourceType = .photoLibrary
                imagePicker.allowsEditing = true
                self.present(imagePicker, animated: true, completion: nil)
            }
    
            let alertaction2 = UIAlertAction(title: "拍照", style: .destructive) { (action) in
                if (!UIImagePickerController.isSourceTypeAvailable(.camera)) {
                    print("设备不支持相机")
                    return
                }
                let imagePicker = UIImagePickerController()
                imagePicker.delegate = self
                imagePicker.sourceType = .camera
                imagePicker.allowsEditing = true
                self.present(imagePicker, animated: true, completion: nil)
            }
    
            let alertAction3 = UIAlertAction(title: "取消", style: .cancel) { (action) in
                print("取消")
            }
    
            alertcontroller.addAction(alertaction)
            alertcontroller.addAction(alertaction2)
            alertcontroller.addAction(alertAction3)
            present(alertcontroller, animated: true, completion: nil)
        }
    
        // MARK: - UIImagePickerControllerDelegate
        func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : Any]) {
            let image = info[UIImagePickerControllerOriginalImage] as! UIImage
            imageView.image = image
            self.dismiss(animated: true, completion: nil)
        }

    六、二维码扫描及识别(建议用真机)

    二维码扫描及识别

    • 核心代码
    // MARK: - 扫描设备设置
        func setupScanSession() {
            do {
                // 设置捕捉设备
                let device = AVCaptureDevice.defaultDevice(withMediaType: AVMediaTypeVideo)
                // 设置设备输入输出
                let input = try AVCaptureDeviceInput(device: device)
                let output = AVCaptureMetadataOutput()
                output.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
    
                // 设置会话
                let  scanSession = AVCaptureSession()
                scanSession.canSetSessionPreset(AVCaptureSessionPresetHigh)
    
                if scanSession.canAddInput(input) {
                    scanSession.addInput(input)
                }
    
                if scanSession.canAddOutput(output) {
                    scanSession.addOutput(output)
                }
    
                // 设置扫描类型(二维码和条形码)
                output.metadataObjectTypes = [
                    AVMetadataObjectTypeQRCode,
                    AVMetadataObjectTypeCode39Code,
                    AVMetadataObjectTypeCode128Code,
                    AVMetadataObjectTypeCode39Mod43Code,
                    AVMetadataObjectTypeEAN13Code,
                    AVMetadataObjectTypeEAN8Code,
                    AVMetadataObjectTypeCode93Code]
    
                // 预览图层
                let scanPreviewLayer = AVCaptureVideoPreviewLayer(session:scanSession)
                scanPreviewLayer!.videoGravity = AVLayerVideoGravityResizeAspectFill
                scanPreviewLayer!.frame = view.layer.bounds
    
                view.layer.insertSublayer(scanPreviewLayer!, at: 0)
    
                // 设置扫描区域
                NotificationCenter.default.addObserver(forName: NSNotification.Name.AVCaptureInputPortFormatDescriptionDidChange, object: nil, queue: nil, using: { (noti) in
                    output.rectOfInterest = (scanPreviewLayer?.metadataOutputRectOfInterest(for:self.scanImageView.frame))!
                })
                // 保存会话
                self.scanSession = scanSession
    
            } catch {
                // 摄像头不可用
                return
            }
        }

    扫描完成后调用

    // MARK: - AVCaptureMetadataOutputObjectsDelegate 扫描捕捉完成
    extension NNScanCodeController : AVCaptureMetadataOutputObjectsDelegate {
        func captureOutput(_ captureOutput: AVCaptureOutput!, didOutputMetadataObjects metadataObjects: [Any]!, from connection: AVCaptureConnection!) {
            // 停止扫描
            scanLine.layer.removeAllAnimations()
            scanSession!.stopRunning()
    
            // 扫完完成
            if metadataObjects.count > 0 {
                if let resultObj = metadataObjects.first as? AVMetadataMachineReadableCodeObject {
                    print(resultObj.stringValue)
                    scanResult.text = "扫描结果:" + resultObj.stringValue
                }
            }
        }
    }

    识别验证码,从相册中选择

    // MARK: - UIImagePickerControllerDelegate, UINavigationControllerDelegate
    extension NNScanCodeController : UIImagePickerControllerDelegate , UINavigationControllerDelegate {
        func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : Any]) {
    
            // 判断是否能取到图片
            guard let image = info[UIImagePickerControllerOriginalImage] as? UIImage else {
                return
            }
            // 转成ciimage
            guard let ciimage = CIImage(image: image) else {
                return
            }
            // 从选中的图片中读取二维码
            // 创建探测器
            let detector = CIDetector(ofType: CIDetectorTypeQRCode, context: nil, options: [CIDetectorAccuracy : CIDetectorAccuracyLow])
            let resoult = (detector?.features(in: ciimage))!
            scanResult.text = "无法识别"
            for result in resoult {
                guard (result as! CIQRCodeFeature).messageString != nil else {
                    return
                }
    
                scanResult.text = "扫描结果:" + (result as! CIQRCodeFeature).messageString!
            }
            picker.dismiss(animated: true, completion: nil)
        }
    }

    七、随机图片验证码封装

    随机图片验证码封装

    • 核心代码
        // MARK: - 绘制图形验证码
        override func draw(_ rect: CGRect) {
            if charString.isEmpty {
                return;
            }
    
            let textString:String = charString
            let charSize = textString.substring(to: textString.startIndex).size(attributes: [NSFontAttributeName : UIFont.systemFont(ofSize: 14)])
            let width = rect.size.width / CGFloat(charCount) - charSize.width - 15;
            let hight = rect.size.height - charSize.height;
            var point: CGPoint
    
            var pointX: CGFloat
            var pointY: CGFloat
            for i in 0..<textString.characters.count {
                let char = CGFloat(i)
                pointX = (CGFloat)(arc4random() % UInt32(Float(width))) + rect.size.width / (CGFloat)(textString.characters.count) * char
                pointY = (CGFloat)(arc4random() % UInt32(Float(hight)))
                point = CGPoint(x: pointX, y: pointY)
                let charStr = textString[textString.index(textString.startIndex, offsetBy:i)]
                let string = String(charStr)
                string.draw(at: point,withAttributes:([NSFontAttributeName : UIFont.systemFont(ofSize: 14)]))
            }
            drawLine(rect)
        }
    
        // MARK: - 绘制干扰线
        func drawLine(_ rect: CGRect) {
            let context = UIGraphicsGetCurrentContext()
            context!.setLineWidth(1.0)
            var pointX = 0.0
            var pointY = 0.0
            for _ in 0..<lineCount {
                context!.setStrokeColor(randomColor().cgColor)
                pointX = Double(arc4random() % UInt32(Float(rect.size.width)))
                pointY = Double(arc4random() % UInt32(Float(rect.size.height)))
                context?.move(to: CGPoint(x: pointX, y: pointY))
                pointX = Double(CGFloat(arc4random() % UInt32(Float(rect.size.width))))
                pointY = Double(CGFloat(arc4random() % UInt32(Float(rect.size.height))))
                context?.addLine(to: CGPoint(x: pointX, y: pointY))
                context!.strokePath()
            }
        }

    OC版本:iOS开发 - 随机图片验证码封装-http://www.jianshu.com/p/936d2e06fd26

    八、圆形输入框封装

    圆形输入框封装

    • 核心代码
        // MARK: - 监听文本输入 核心操作
        func textFieldDidChange(_ textField: UITextField) {
            let i = textField.text?.characters.count
            if i! > labelCount {
                return
            }
            if i == 0 {
                ((labelArr.object(at: 0)) as! UILabel).text = ""
                ((labelArr.object(at: 0)) as! UILabel).layer.borderColor = defaultColor.cgColor
            } else {
                ((labelArr.object(at: (i! - 1))) as! UILabel).text = (textField.text! as NSString).substring(with: NSMakeRange(i! - 1, 1))
                ((labelArr.object(at: (i! - 1))) as! UILabel).layer.borderColor = changedColor.cgColor
                ((labelArr.object(at: (i! - 1))) as! UILabel).textColor = changedColor
                if labelCount > i! {
                    ((labelArr.object(at: (i!))) as! UILabel).text = ""
                    ((labelArr.object(at: (i!))) as! UILabel).layer.borderColor = defaultColor.cgColor
                }
            }
        }
    
        // MARK: - setupUI
        func setupUI() {
            setupTextField()
            var labelX = CGFloat()
            let labelY : CGFloat = 0.0
            let labelWidth = self.width / CGFloat(labelCount)
            let sideLength = labelWidth < self.height ? labelWidth : self.height
    
            for i in 0..<labelCount {
                if i == 0 {
                    labelX = 0
                } else {
                    labelX = CGFloat(i) * (sideLength + labelDistance)
                }
                let label = UILabel(frame: CGRect(x: labelX, y: labelY, width: sideLength, height: sideLength))
                self.addSubview(label)
                label.textAlignment = NSTextAlignment.center
                label.layer.borderColor = UIColor.black.cgColor
                label.layer.borderWidth = 1.0
                label.layer.cornerRadius = sideLength / 2.0
                labelArr.add(label)
            }
        }
    
        // MARK: - UITextFieldDelegate
        // MARK: 监听输入框
        func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
            // 允许删除
            if (string.characters.count == 0) {
                return true
            } else if (textField.text?.characters.count)! >= labelCount {
                return false
            } else {
                return true
            }
        }
        // MARK: 回车收起键盘
        func textFieldShouldReturn(_ textField: UITextField) -> Bool {
            textField.resignFirstResponder()
            return false
        }

    OC版本:iOS开发 - 圆形验证码(或密码)输入框的封装-http://www.jianshu.com/p/fce6bd4038eb

    九、第三方库 SnapKit 用法

    第三方库 SnapKit 用法

    • 示例代码
        func addRedView() {
            redView.backgroundColor = UIColor.red
            view.addSubview(redView)
    
            // redView 距离父视图四条边的距离都是 50
            redView.snp.makeConstraints { (make) in
                make.edges.equalTo(view).inset(50)
            }
        }
    
        func addBlueView() {
            blueView.backgroundColor = UIColor.blue
            view.addSubview(blueView)
    
            // blueView 左边距离父视图为 0;上边距离父视图为 0;size 是(5050)
            blueView.snp.makeConstraints { (make) in
                make.left.equalTo(0)
                make.top.equalTo(0)
                make.size.equalTo(CGSize(width: 50, height: 50))
            }
        }
    
        func addBlackView() {
            blackView.backgroundColor = UIColor.black
            view.addSubview(blackView)
    
            // blackView 左边和 redView 的右边距离为 0;大小与 blueView 相同;且与 blueView 上对齐
            blackView.snp.makeConstraints { (make) in
                make.left.equalTo(redView.snp.right)
                make.size.equalTo(blueView)
                make.top.equalTo(blueView)
            }
        }
    
        func addCyanView() {
            cyanView.backgroundColor = UIColor.cyan
            view.addSubview(cyanView)
    
            // cyanView 与 blueView 左对齐;cyanView 的顶部距离 redView 的底部 10;cyanView 的高是40;cyanView 与 blueView 等宽
            cyanView.snp.makeConstraints { (make) in
                make.trailing.equalTo(blueView)
                make.top.equalTo(redView.snp.bottom).offset(10)
                make.height.equalTo(40)
                make.width.equalTo(blueView)
            }
        }
    
        func addYellowView() {
            yellowView.backgroundColor = UIColor.yellow
            view.addSubview(yellowView)
    
            // yellowView 顶部与 redView 的底部对齐;yellowView 与 blackView 左对齐;yellowView 与 blueView 相同大小
            yellowView.snp.makeConstraints { (make) in
                make.top.equalTo(redView.snp.bottom)
                make.trailing.equalTo(blackView)
                make.size.equalTo(blueView)
            }
        }
    
        func addWhiteView() {
            whiteView.backgroundColor = UIColor.white
            redView.addSubview(whiteView)
    
            // whiteView 的父视图是 redView,距离父视图四条边的距离分别是(30103010)
    
            whiteView.snp.makeConstraints { (make) in
                // 第一种方式
                make.edges.equalTo(redView).inset(UIEdgeInsets(top: 30, left: 10, bottom: 30, right: 10))
                // 第二种方式
    //            make.top.equalTo(redView).offset(30)
    //            make.left.equalTo(redView).offset(10)
    //            make.bottom.equalTo(redView).offset(-30)
    //            make.right.equalTo(redView).offset(-10)
                // 第三种方式
    //            make.top.left.bottom.right.equalTo(redView).inset(UIEdgeInsets(top: 30, left: 10, bottom: 30, right: 10))
            }
        }
    




    详情代码,请移步到 https://github.com/liuzhongning/NNMintFurniture 中查看,如有疑问或有建议的地方,欢迎讨论。另外代码中有一个名为 guide.swift 的类,简单标出了代码的结构,更方便阅读。
    会持续更新……
    展开全文
  • 之前Swift一直不稳定,看过书,读过blog,今天开始,我以对比(OC:Swift)的形式将swift中常见的语法,以及注意事项,欢迎大家跟我一起学习Swift。// 1.导入框架 // OC导入框架 #import &lt;UIKit/UIKit.h&....

    Swift,苹果于2014年在苹果开发者大会发布的新开发语音,可与OC共同运行于Mac OS 和ios平台,用于搭建基于苹果平台的应用程序。之前Swift一直不稳定,看过书,读过blog,今天开始,我以对比(OC:Swift)的形式将swift中常见的语法,以及注意事项,欢迎大家跟我一起学习Swift。

    // 1.导入框架
    // OC导入框架   #import <UIKit/UIKit.h>
    // Swift 导入框架   import UIKit
    
    // 2.定义变量
    // OC 定义变量int a = 10; a = 5;
    // Swift 定义变量  var a:Int = 10
    
    // 3.定义常量
    // OC:  const int a = 5;
    // Swift:   let a:Int = 5;
    
    // 4.创建对象
    // OC:  UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 200, 200)];
    //      [view setBackgroundColor:[UIColor redColor]];
    // Swift:  let view:UIView = UIView(frame: CGRect(x: 0, y: 0, width: 200, height: 200))
    //      view.backgroundColor = UIColor.red;
    
    // 5.控制台输出
    // OC:   int const a = 10; NSLog(@"a=%zd",a);
    // Swift:   let a:Int = 10; print("a=\(a)");


        


    展开全文
  • 通过博客的方式来记录自己的学习Swift过程,同时把学习的内容分享给大家,希望能为你提供一点帮助

    转载请注明出处:http://blog.csdn.net/xiaojimanman/article/details/53396266

    http://www.llwjy.com/blogdetail/6a852f4e708d8d4b8a18a1115f345443.html

    个人博客站已经上线了,网址 www.llwjy.com ~欢迎各位吐槽~

    -------------------------------------------------------------------------------------------------

          在开始之前先打一个小小的广告,自己创建一个QQ群:321903218,点击链接加入群【Lucene案例开发】,主要用于交流如何使用Lucene来创建站内搜索后台,同时还会不定期的在群内开相关的公开课,感兴趣的童鞋可以加入交流。


          最近人生遇到一些变故,打算学习一门新的编程语言来充实自己的生活,自己会通过博客的方式来记录自己的学习过程,同时把学习的内容分享给大家,万一某一天你也想学习swift的时候,可以给你提供一些帮助。


    编程环境

          学习苹果的开发语言,当然需要有一个Mac系统的苹果电脑,相信如果你真的想学习相关的开发,这个对你不是什么难事。
          据我初步的了解,苹果的相关开发使用的IDE都是Xcode这个软件,我们通过App Store下载相关的Xcode软件(软件大小4G多,下载速度完全看自己的网速),我使用的是8.1这个版本。


    Hello World
          程序员的第一个程序就是Hello World,下面就来介绍下如何来创建一个简单的Hello World程序。
          为了以后学习的方便,先创建一个工作空间(Workspace),打开Xcode软件,如下图

    img

          我们通过File--New--Workspace(control + command + n)创建一个工作空间,命名为swift,路径选择自己的文件夹。

    img

          然后新建一个项目 File--New--Project(shift + command + n)新建一个项目,第一个项目我们先创建一个控制台程序。

    img

          点击Next

    img

          这里项目名喔命名为Swift001,语言选择Swift。点击Next--Create。我们从左侧目录找到main.swift文件,这里又两行代码:

    img

          我们点击左上角的运行按钮

    img

    img


          一个简单的环境就这样完成了,学习还在继续。。。。。


    -------------------------------------------------------------------------------------------------
    小福利
    -------------------------------------------------------------------------------------------------
          个人在极客学院上《Lucene案例开发》课程已经上线了,欢迎大家吐槽~

    第一课:Lucene概述

    第二课:Lucene 常用功能介绍

    第三课:网络爬虫

    第四课:数据库连接池

    第五课:小说网站的采集

    第六课:小说网站数据库操作

    第七课:小说网站分布式爬虫的实现

    第八课:Lucene实时搜索

    第九课:索引的基础操作


    展开全文
  • 目前随着公司开发模式的变更,swift也显得越发重要,相对来说...好了,废话不多说了,直接把我对swift的语法的一些理解奉献给大家,希望能对学习swift语法的朋友有所帮助,如有不足之处,还请多多包涵,如果有错误之处,欢迎指正

    目前随着公司开发模式的变更,swift也显得越发重要,相对来说,swift语言更加简洁,严谨.但对于我来说,感觉swift细节的处理很繁琐,可能是还没适应的缘故吧.基本每写一句代码,都要对变量的数据类型进行判断,还要进行强转等等.

    好了,废话不多说了,直接把我对swift的语法的一些理解奉献给大家,希望能对学习swift语法的朋友有所帮助,如有不足之处,还请多多包涵,如果有错误之处,欢迎指正

    Swift 介绍

    简介
    Swift 语言由苹果公司在 2014 年推出,用来撰写 OS X 和 iOS 应用程序
    2014 年,在 Apple WWDC 发布

    历史
    2010 年 7 月,苹果开发者工具部门总监 Chris Lattner 开始着手 Swift 编程语言的设计工作
    用一年时间,完成基本架构
    Swift 大约历经 4 年的开发期,2014 年 6 月发表
     
    克里斯·拉特纳何许人?
              LLVM 项目的主要发起人与作者之一
              Clang 编译器的作者
              苹果公司『开发者工具』部门的主管
              领导Xcode、Instruments等编译器团队
              Swift的大部分基础架构均由他1人完成
     
    特点
         从它的语法中能看到`Objective-C、JavaScript、C#、Python`等语言的影子
         语法简单、代码简洁、使用方便
         可与Objective-C混合使用(相互调用)
         提供了类似 Java 的名字空间(namespace)、泛型(generic)、运算对象重载(operator overloading)
     
    为什么设计Swift语言
         让应用开发更简单、更快、更稳定
         确保最终应用有着更好的质量
     
    Swift初体验
    Playground是什么?
    从Xcode6开始出现(Swift开始出现)
    翻译为:操场/游乐场
    对于学习Swift基本语法非常方便
         所见即所得(快速查看结果)
         语法特性发生改变时,可以快速查看.
     
    一.Swift最基本的语法变化
     
    1.导入框架  
    1 OC: #import <UIKit/UIKit.h>
    2 Swift: import UIKit 
    2.定义标识符
         OC: int a = 20;
         Swift: let a : Int = 20   ==  let a = 20     
     
         定义标识符格式: let / var 标识符 : 数据类型 = 赋值    
         注意:let声明的是常量,不可以对常量重新赋值
     
         Swift中定义标识符,必须声明该标识符是变量(var)还是常量(let)
         注意:在swift中如果一行代码中只有一条语句,那么语句后面的 ;(分号) 可以省略
                 一行内有多条语句 ; 不可以省略,   不建议一行写多条语句
     
    3.Swift中的打印    
    1 OC: NSLog(@"Hello world”);  /  NSLog(@"%d", a);
    2 //Swift中字符串不需要@
    3 print(a)   /   print("hello world")
     
    二.常量&变量
     
    1.什么是常量和变量?
     
         在Swift中规定:在定义一个标识符时,必须明确说明该标识符是常量还是变量
         使用let来定义常量,定义之后,不能进行修改
         使用var来定义变量,定义之后,可以进行修改
     
    2.常量个变量的使用注意
     
         在使用中,建议先使用常量,这样更安全,防止不小心修改之前的值
         如果需要修改时,再把常量修改为变量
         注意:常量的本质是,指向的内存地址不能修改,但可以找到内存地址对应的对象,修改对象内部的属性
    1 let view : UIView = UIView()
    2 view.alpha = 0.5
    3 view.backgroundColor = UIColor.orangeColor()
     
    三.类型推导
     
    1.什么是类型推导?
         在Swift中,如果在定义标识符的同时直接对其进行赋值,那么系统会自动根据赋的值的数据类型,推导出标识符的类型
         如果定义标识符的同时直接赋值,那么标识符后面的数据类型可以省略
         可以通过option + 鼠标左键来查看标识符的类型
    1 let n = 3.14
    2 let View = UIView()
     
    四.Swift中的基本运算
     
    1.swift中在进行基本运算时,必须保证两个参与运算的值得数据类型一致,否则会报错
         因为swift中没有隐式转换
    1 let m = 20
    2 let n = 3.44
    3 // let result = m + n 错误写法 
    2.数据类型的转化
         将Int 转换为 Double  Double(m)
         将Double 转换为 Int Int(n)
    1 let a : Double = 2.44
    2 let b : CGFloat = 4.55
    3 let result1 = a + Double(b)
     
    五.逻辑分支
     
    1.什么是逻辑分支?
         分支就是if / witch / 三目运算符 等判断语句
         通过分支语句可以控制程序的执行流程
     
    2.if分支语句
     OC中if的写法 : BOOL --> YES/NO
    复制代码
    1  int a = 20
    2  if (a > 0) {
    3     NSLog(@"a大于0")
    4  }
    5  
    6  if (a) {
    7     NSLog(@"a不等于0")
    8  }
    复制代码
     Swift和OC的差异
        1. if后面的()可以省略掉
        2. swift中没有非0(nil)即真  Bool --> true/false
    复制代码
    1 let a = 20
    2 if a > 0 {
    3     print("a大于0")
    4 } else {
    5     print("a不大于0")
    6 }
    7  
    复制代码
    3.三目运算符
         swift中的三目运算符合OC没什么差别
    let result = m > n ? m : n
    4.guard的使用
     
         4.1 guard是Swift2.0新增的语法
     
         4.2 它与if语句非常类似,它设计的目的是提高程序的可读性
     
         4.3 guard语句必须带有else语句,它的语法如下:
     
              4.3.1当条件表达式为true时候跳过else语句中的内容,执行语句组内容
     
              4.3.2条件表达式为false时候执行else语句中的内容,跳转语句一般是return、break、continue和throw
    复制代码
     1 func online(age : Int , IDCard : Bool , money : Int)  {
     2     guard age >= 18 else {
     3         print("回家叫家长")
     4         return
     5     }
     6     guard IDCard == true else {
     7         print("回家拿身份证")
     8         return
     9     }
    10     guard money >= 5 else {
    11         print("回家拿钱")
    12         return
    13     }
    14     print("留下来上网")
    15 }
    16 online(19, IDCard: true, money: 4
    复制代码
     
    5.switch分支
     
         5.1苹果在swift中对swift中对switch进行了很大的加强
     
         5.2 Swift中switch和OC中switch的差异
              switch中后面的()可以省略
              case结束之后可以不加break,也不会产生case穿透
             补充:如果希望产生case穿透,需要在语句结束之后加上fallthrough
                     在swift中switch的case后面可以跟上多个条件, 并且多个条件以 , 分割 
    复制代码
    1 switch sex {
    2 case 0, 1:
    3     print("正常")
    4 default:
    5     print("非正常人")
    6 }
    复制代码

          5.3 swift支持多种数据类型判断 

    复制代码
     1 //浮点型switch判断
     2 switch m {
     3 case 3.14:
     4     print("m是π")
     5 default:
     6     print("m非π")
     7 }
     8  
     9 //字符串switch判断
    10 switch opration {
    11     case "+":
    12         result = a + b
    13     case "-":
    14         result = a - b
    15     case "*":
    16         result = a * b
    17     case "/":
    18         result = a / b
    19 default:
    20     print("非法操作")
    21 }
    22  
    复制代码
    判断区间类型
    什么是区间?
         通常我们指的是数字区间:0~10,100~200
    swift中的区间常见有两种
         半开半闭区间:0..<10 表示:0~9,不包括10
         闭区间:0...10 表示:0~10
    复制代码
     1 let score = 92
     2 
     3 switch score {
     4 case 0..<60:
     5     print("不及格")
     6 case 60..<80:
     7     print("及格")
     8 case 80..<90:
     9     print("良好")
    10 case 90...100:
    11     print("优秀")
    12 default:
    13     print("不合理分数")
    14 }
    15  
    复制代码


    六.循环
     
    常见的循环有:for/while/do while
    1.for循环
         1.1 OC中的for循环写法
    1   for (int i = 0; i < 10; i++) {
    2  
    3   }     
         1.2 swift中的写法 
    复制代码
     1 // 区间遍历 0..<10 0...9
     2 for i in 0..<10 {
     3     print(i)
     4 }
     5 
     6 for i in 0...9 {
     7     print(i)
     8 }
     9  
    10 // 如果一个标识符不需要使用, 那么可以通过 _ 来代替
    11 for _ in 0..<10 {
    12     print("hello world")
    13 }
    复制代码
    2.while循环
         2.1 OC中的写法
     int a = 20
     while (a) {
     }
         2.2 swift中的写法
              2.2.1while后面的()可以省略
              2.2.2没有非0(nil)即真
    1 var i = 10
    2 while i > 0 {
    3     print(i)
    4     i -= 1
    5 }
     
    3.do while循环
    复制代码
    1 // 区别: 不再使用do while --> repeat while
    2 var m = 0
    3 repeat {
    4     print(m)
    5     m += 1
    6 } while m < 10
    复制代码
     
    七.字符串
    1.字符串的介绍 
         1.1字符串在任何的开发中使用都是非常频繁的
     
         1.2OC和Swift中字符串的区别
              在OC中字符串类型时NSString,在Swift中字符串类型是String
              OC中字符串@"",Swift中字符串""
     
         1.3使用 String 的原因
              String 是一个结构体,性能更高
              NSString 是一个 OC 对象,性能略差
              String 支持直接遍历
              String 提供了 String 和 NSString之间的无缝转换
     
    2.字符串的定义
         2.1定义不可变字符串
    let str = "hello swift"
         2.2定义可变字符串
    var strM = "hello world"
    strM = "hello china" 
     
    3.获取字符串的长度
         先获取字符集合,再获取集合的count属性
    let length = str.characters.count
     
    4.遍历字符串
    for c in str.characters {
        print(c)
    }
     
     
    5.字符串的拼接
         5.1字符串之间的拼接
    let str1 = "Hello"
    let str2 = "World"
    let str3 = str1 + str2
         
         5.2字符串和其它标识符间的拼接
    let name = "lgp"
    let age = 18
    let height = 1.98
    let infoStr = "my name is \(name), age is \(age), height is \(height)"
     
         5.3字符串格式化
              比如时间:03:04  如果显示 3 : 4 就不好.所以需要格式化
    let min = 3
    let second = 4
    let timeStr = String(format: "%02d:%02d", arguments: [min, second]) 
     
    6.字符串的截取
     
         6.1简单的方式是将String转成NSString来使用
              在标识符后加:as NSString即可
    复制代码
    1 // 1.方式一: 将String类型转成NSString类型, 再进行截取
    2 // (urlString as NSString) --> NSString
    3 let header = (urlString as NSString).substringToIndex(3)
    4 let footer = (urlString as NSString).substringFromIndex(10)
    5 let range = NSMakeRange(4, 5)
    6 let middle = (urlString as NSString).substringWithRange(range)
    复制代码
         6.1Swift中提供了特殊的截取方式
              该方式非常麻烦
              Index创建较为麻烦
    复制代码
    1 // 2.方式二: Swift原生方式进行截取
    2 let headerIndex = urlString.startIndex.advancedBy(3)
    3 let header1 = urlString.substringToIndex(headerIndex)
    4 
    5 let footerIndex = urlString.endIndex.advancedBy(-3)
    6 let footer1 = urlString.substringFromIndex(footerIndex)
    7  
    8 let range1 = headerIndex.advancedBy(1)..<footerIndex.advancedBy(-1)
    9 let middle1 = urlString.substringWithRange(range1)
    复制代码
     
    八.数组的使用
     
    1.数组的介绍
         1.1 数组(Array)是一串有序的由相同类型元素构成的集合
         1.2 数组中的集合元素是有序的,可以重复出现
         1.3 Swift中的数组
              swift数组类型是Array,是一个泛型集合
     
    2.数组的初始化
         2.1 定义不可变数组,使用let修饰  
              注意:不可变数组要在定义的同时初始化,否则没有意义
         let array = ["why", "yz"]    
     
         2.2 定义可变数组,使用var修饰
              注意:数组是泛型集合,必须确定该数组中存放元素的类型
      //基本写法   
      var arrayM = Array<String>()
      //单写法
      var arrayM = [String]()
     
    3.对可变数组的基本操作(增删改查)
         3.1 添加元素
    arrayM.append("ljp")    
         3.2 删除元素 
    let removeItem = arrayM.removeAtIndex(1)  返回值为删除的元素
    arrayM.removeAll()
         3.3 修改元素
    arrayM[0] = "why"
         3.4 查找元素(根据下标获取元素)
    let item = arrayM[0]
     
    4.数组的遍历
         4.1 遍历下标值
    1 for i in 0..<array.count {
    2     print(array[i])
    3 }
         4.2遍历元素
    for name in array {
        print(name)
    } 
          4.3遍历下标值和元素
    1 for (index, name) in array.enumerate() {
    2     print(index)
    3     print(name)
    4 }

     

    5.数组的合并
         相同类型的数组可以相加进行合并
         可变数组和不可变的数组也能合并
    1 let array1 = ["why", "yz"]
    2 let array2 = ["lmj", "lnj"]
    3 let resultArray = array1 + array2
     
    九.字典的使用
     
    1.字典的介绍
         1.1字典允许按照某个键来访问元素
         1.2字典是由两部分集合构成的,一个是键(key)集合,一个是值(value)集合
         1.3键集合是不能有重复元素的,而值集合是可以重复的,键和值是成对出现的
         1.4Swift中的字典
              Swift字典类型是Dictionary,也是一个泛型集合
     
    2.字典的初始化
         2.1 定义不可变字典,使用let修饰  
              注意:不可变字典要在定义的同时初始化,否则没有意义
                系统会根据[]中存放的是键值对,还是一个个元素,来判断该[]是一个数组还是字典   
    let dict = ["name" : "why", "age" : 18, "height" : 1.88]
        
         2.2 定义可变字典,使用var修饰
              注意:字典是泛型集合,必须制定该数组中存放元素的类型
         基本写法      
    var dictM = Dictionary<String, NSObject>()
         简单写法   
    var dictM = [String : NSObject]() // 常见
     
    3.对可变字典的基本操作(增删改查)
         3.1 添加元素
    dictM.updateValue("why", forKey: "name")    
         3.2 删除元素 
    1 dictM.removeValueForKey("age") 
         3.3 修改元素
    1 //如果原有没有对应的key/value, 那么就添加键值对
    2 // 如果原有已经有对应的key/value, 那么直接修改
    3 dictM.updateValue("1.77", forKey: "height")
    4 dictM["name"] = "why"
         3.4 查找元素(获取元素)
    1 let item = dictM["name"]
     
    4.字典的遍历
         4.1 遍历字典中所有的key
    1 for key in dict.keys {
    2     print(key)
    3 }       
      4.2 遍历字典中所有的value
    1 for value in dict.values {
    2     print(value)
    3 }
          4.3 遍历字典中所有的key / value
    1 for (key, value) in dict {
    2     print(key)
    3     print(value)
    4 }
     
    5.字典的合并
         相同类型的字典也不可以相加进行合并
         可以把其中一个字典改为可变的,遍历不可变得字典,把元素一个一个的添加到另一个不可变字典中
    复制代码
    1 let dict1 = ["name" : "why", "age" : 18]
    2 var dict2 = ["height" : 1.88, "phoneNum" : "+86 110"]
    3 
    4 for (key, value) in dict1 {
    5     dict2[key] = value
    6 }
    7  
    复制代码
     
    十.元组的使用
    1.元组的介绍
         1.1元组是Swift中特有的,OC中并没有相关类型
         1.2它是什么呢?
              1.2.1 它是一种数据结构,在数学中应用广泛
              1.2.2 类似于数组或者字典
              1.2.3 可以用于定义一组数据
              1.2.4 组成元组类型的数据可以称为“元素”
     
    2.为什么使用元组?
         如果字典或数组保存多种数据类型,那么从字典会数组取出来的数据类型是NSObject,我们使用的时候很不方便,要先转换为真实类型
         元组保存多种数据类型,取出来就是该数据的真实类型,不需要转换就能直接使用
     
    3.元组的定义
    1 let infoTuple = ("why", 18, 1.88, "+86 110")
    2 // 使用元组描述一个人的信息
    3 ("1001", "张三", 30, 90)
    4 // 给元素加上元素名称,之后可以通过元素名称访问元素
    5 (id:"1001", name:"张三", english_score:30, chinese_score:90)

     

     

    前言:swift语法基础篇(二)来了,想学习swift的朋友可以拿去参考哦,有兴趣可以相互探讨,共同学习哦. 
     
     
    一.可选类型(重点内容)
     
    1.什么是可选类型?
     
         1.1在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
         1.2在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言)
         1.3但是开发中赋值nil,在所难免.因此推出了可选类型
          目的:让代码更加严谨
     
    2.可选类型的取值
         可选类型要么是:空值 , 要么是:有值
         只有为可选类型,才能赋值为nil
     
    3.定义可选类型
           3.1 普通写法
      var name : Optional<String> = nil
       
           3.2 简单写法(语法糖) 
    var name : String? = nil
     
    4.给可选类型赋值
         4.1 普通赋值
    name = Optional("why")
         
         4.2 直接赋值
    name = "why" // 系统会对字符串进行包装Optional, 再进行赋值
     
    5.强制解包(取出可选类型中具体的值)
         5.1 为什么要强制解包
              可选类型的值的格式为: Optional("why") 我们要想使用其真实值,必须要解包
     
         5.2 怎么解包?
              在可选类型的标识符后面加!
     print(name!)
              注意:解包前,要先判断可选类型是否为nil , 如果为nil,强制解包会报错
     
    6.可选绑定
    1 if let name = name {
    2     print(name)
    3     print(name)
    4 }
         6.1 系统先判断可选类型是否为nil,如果为nil,就跳过{}中的内容
         6.2 如果有值,会先对name进行强制解包,然后把解包结果赋值给name
     

     

    7.可选类型的应用场景
         可选类型能让代码变得更加严谨
         类型转换后的数据类型一般都为可选类型,因为转换不成功就为nil , 只有可选类型能接收nil
     
         7.1字符串类型转Int类型
     
         
     
         可以看到,类型转换后的类型为可选类型
         使用转换后的结果的时候,一定要先判断是否为nil, 如果为nil, 使用会报错
     
         7.2 根据string创建一个NSURL
    复制代码
    1 let urlString = "www.baidu.com"
    2 
    3 let url : NSURL? = NSURL(string: urlString)
    4 if let url = url {
    5     let request = NSURLRequest(URL: url)
    6
    复制代码
         if let url = url 内部做了以下判断:
         1.判断url是否为nil,为nil 就跳过{}中的内容
         2.不为nil,就对url进行强制解包
         3.将解包后的结果赋值给前面的url
     
         7.3 根据一个plist文件创建一个数组
    1 let path = NSBundle.mainBundle().pathForResource("123.plist", ofType: nil)
    2 
    3 if let path = path {
    4     NSArray(contentsOfFile:path)
    5 }
     
    二.类型转化
    1.is的使用:判断是否是某种类型
    复制代码
     1 //1.is的使用
     2 let infoArray = ["why" , 18 , 1.98]
     3 let item = infoArray[1]
     4  
     5 //item.isKindOfClass(UIButton.self)
     6 
     7 //string是结构体,不能用isKindOfClass
     8 if item is String {
     9     print("是字符串")
    10 }else {
    11     print("不是字符串")
    12 }
    复制代码

     

    2.as的使用
         2.1 as直接使用: swift类型和oc类型的转化
    1 let urlString = "www.baidu.com"
    2 (urlString as NSString).substringToIndex(3)
     
         2.2 as? 的使用: 将NSObject转成某一确定类型的可选类型
     
    复制代码
     1 let item1 = infoArray[0]
     2 let name = item1 as? String
     3 if let name = name {
     4     print(name.characters.count)
     5 }
     6 简写:
     7 if let name = infoArray[0] as? String {
     8     print(name.characters.count)
     9 }
    复制代码
       
        2.3 as! 的使用: 将NSObject转成确定的类型,但如果转化不成功,则程序会崩溃
    1 let count = (infoArray[0] as! String).characters.count
     
    三.函数
     
    1.函数的介绍
     
        1.1 函数相当于OC中的方法
        1.2 函数的格式如下
         func 函数名(参数列表) -> 返回值类型 {
             代码块
             return 返回值
         }
         1.3 func是关键字,多个参数列表之间可以用逗号(,)分隔,也可以没有参数
         1.4 使用箭头“->”指向返回值类型
         1.5 如果函数没有返回值,返回值为Void.并且“-> 返回值类型”部分可以省略
     
    2.常见的函数类型
         
     
    3.内部参数和外部参数
     
         3.1 什么是内部参数
              3.11 在函数内部就可以看到的参数(标识符)就是内部参数
              3.12 默认所有的参数都是内部参数
     
         3.2 什么是外部参数
              3.21 在函数外部就可以看到的参数(标识符)就是外部参数
              3.22 默认从第二个参数开始都是外部参数
              3.23 如果想让第一个参数成为外部参数,可以设置标签:在变量名前加标签即可
              3.24 如果不想要外部参数,可以在参数名称前加_  (_ 和参数名称中间要加一个 空格)
              3.25 也可以给外部参数设置标签  ,相当于给外部参数起别名
     
     
    4.默认参数
         4.1 什么是默认参数?
              如果一个函数需要参数,而我们调用的时候又不想传参,那么在设计函数的时候,可以给函数一个默认的参数
              如果调用函数,不传参数,就按照默认的参数对函数进行处理
     

     

    5.可变参数
         5.1 swift中函数的参数个数可以变化,它可以接收不确定数量的输入类型参数
         5.2 它们必须具有相同的类型
         5.3 我们可以通过在参数类型名后面加入(...)的方式来指示这是可变参数
         作用:方便需求变化时,更改代码,当参数个数需求变更或很多时,可以轻松些代码

     

    6.指针参数
         6.1 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
         6.2 必须是变量,因为需要在内部改变其值
         6.3 Swift提供的inout关键字就可以实现
     

     

     
    7.函数的嵌套
         swift中函数是可以嵌套的,即函数中包含函数,但是不推荐该写法
         OC中方法不可以嵌套
    复制代码
     1 // 函数的嵌套
     2 let value = 55
     3 func test() {
     4     func demo() {
     5         print("demo \(value)")
     6     }
     7     print("test")
     8     demo()
     9 }
    10 demo() // 错误  必须在对应的作用域内调用
    11 test() // 执行函数会先打印'test',再打印'demo'
    复制代码
     
    8.函数的类型
         8.1什么是函数的类型?
              每个函数都有自己的类型, 函数的类型由 函数的参数类型和返回值类型组成
    复制代码
    1 // 定义两个函数
    2 func addTwoInts(a : Int, b : Int) -> Int {
    3     return a + b
    4 }
    5 
    6 func multiplyTwoInt(a : Int, b : Int) -> Int {
    7     return a * b
    8 }
    9  
    复制代码
         这两个函数的类型是 (Int, Int) -> Int
     
         8.2抽取两个函数的类型,并且使用
    复制代码
     1 // 定义函数的类型
     2 var mathFunction : (Int, Int) -> Int = addTwoInts
     3 
     4 // 使用函数的名称
     5 mathFunction(10, 20)
     6 
     7 // 给函数的标识符赋值其他值
     8 mathFunction = multiplyTwoInt
     9 
    10 // 使用函数的名称
    11 mathFunction(10, 20)
    复制代码
     
         8.3 函数作为方法的参数
    复制代码
    1 // 3.将函数的类型作为方法的参数
    2 func printResult(a : Int, b : Int, calculateMethod : (Int, Int) -> Int) {
    3     print(calculateMethod(a, b))
    4 }
    5 
    6 printResult(10, b: 20, calculateMethod: addTwoInts)
    7 printResult(10, b: 20, calculateMethod: multiplyTwoInt)
    复制代码
     
         8.4函数作为方法的返回值
    复制代码
     1 // 1.定义两个函数
     2 func stepForward(num : Int) -> Int {
     3     return num + 1
     4 }
     5 
     6 func stepBackward(num : Int) -> Int {
     7     return num - 1
     8 }
     9 
    10 // 2.定义一个变量,希望该变量经过计算得到0
    11 var num = -4
    12 
    13 // 3.定义获取哪一个函数
    14 func getOprationMethod(num : Int) -> (Int) -> Int {
    15     return num <= 0 ? stepForward : stepBackward
    16 }
    17  
    18 // 4.for循环进行操作
    19 while num != 0 {
    20     let oprationMethod = getOprationMethod(num)
    21     num = oprationMethod(num)
    22     print(num)
    23 }
    复制代码

     
    四.枚举类型
     
    1.什么是枚举?
     
         1.1 枚举是一种数据类型,枚举是一组具有共同特性的数据的集合
         1.2 枚举可以让我们更安全的使用数据
         1.3 oc中只能对枚举成员赋值为整型
         1.4 swift中的枚举更加灵活,可以给每一枚举成员赋值,这些值可以为字符,字符串,整型,浮点型等
     
    2.枚举类型的定义
     
         2.1 使用enum关键词,把枚举定义在一个大括号内
    1      enum <#name#> {
    2           case <#case#>
    3      }
     
         2.2 case关键词表明新的一行成员值将被定义
     
         2.3 不像 C 和 Objective-C 一样,Swift 的枚举成员在被创建时不会被赋予一个默认的整数值 (0.1.2.3...)
     
         2.4 定义方式二: 多个成员值可以写在同一行
    1 enum Planet {
    2   case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
    3 }
         
    3.枚举类型的使用
    复制代码
     1 enum Direction : Int{
     2     case East = 1 , West , North , Sourth
     3 }
     4 //完整写法
     5 let d : Direction = Direction.North
     6 //简单写法:根据上下文能推导出确定的类型
     7 var d1 = Direction.East
     8 d1 = .West
     9 
    10 //枚举类型的使用
    11 let btn = UIButton(type: .Custom)
    复制代码
     
    4.给枚举类型赋值
     
         4.1 枚举类型赋值可以是字符串/字符/整型/浮点型
         4.2 注意: 如果给枚举类型赋值, 则必须在枚举类型后面说明赋值的类型 
         4.3 给枚举类型赋的值的类型,必须跟说明的类型一致,否则会报错
    复制代码
     1 let btn = UIButton(type: .Custom)
     2 
     3 enum Direction : String{
     4     case East = "1"
     5     case West = "3"
     6     case North = "6"
     7     case Sourth = "9"
     8 }
     9 var b : Direction = .West
    10  
    11 let a = Direction(rawValue: “6”) 
    复制代码
      
    注意: 通过rawValue:方式取出来的值的类型  为 对应类型的 可选类型
         因为通过这种方法不一定能取出来值,可能为nil   所以为可选类型  比较严谨
     
         4.4给枚举类型赋值方式二
    1      enum Direction2 : Int{
    2          case East = 1 , West , North , Sourth
    3 //只要给第一个成员赋值,会自动按照递增的方式给后面的成员赋值
    4 //相当于 West = 2, North = 3, Sourth = 4
    5 //注意:这种赋值方法只对整型有效,赋值其它类型无效
     
    五.结构体
     
    1.什么是结构体?
     
         1.1结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合
         1.2结构体(struct)指的是一种数据结构
         1.3结构体是值类型,在方法中传递时是值传递
     
    2.结构的定义格式
     
    struct 结构体名称 {
        // 属性和方法
    }
     
    3.在swift中对结构体进行了很大的增强
     
         3.1 扩充构造函数
     
              3.11 默认情况下,创建Location  只能使用Location (x: Double , y : Double) 方法创建
              3.12 但为了让结构体的使用更加灵活, swift中,可以对其构造方法就行扩充 
              3.13 注意: 结构体中值必须为可变的var ,否则没有意义
     
            
            

     

     
         3.2 为结构体扩充方法
      
     
    六.类
     
    1.类的介绍和定义
     
         1.1 Swift也是一门面向对象开发的语言,面向对象的基础是类,类产生了对象
     
         1.2 在swift中如何定义类?
              class是Swift中的关键字,用于定义类
     
         1.3 定义的类,可以没有父类.那么该类是rootClass
     
         1.4 通常情况下,定义类时.继承自NSObject
     
    复制代码
     1 class 类名 : SuperClass {
     2     // 定义属性和方法
     3 }
     4 class Person {
     5     var name : String = ""
     6     var age : Int = 0
     7 }
     8 let p = Person()
     9 p.name = "lkj"
    10 p.age = 18    
    复制代码
     
    2.类的属性定义
     
         2.1类的属性介绍:Swift中类的属性有多种
         存储属性:存储实例的常量和变量
         计算属性:通过某种方式计算出来的属性
         类属性:与整个类自身相关的属性
     

     

    3.监听属性的改变
     
         3.1 在OC中我们可以重写set方法来监听属性的改变 (kvc监听系统属性的改变)
         3.2 Swift中可以通过属性观察者来监听和响应属性值的变化
         3.3 通常是监听存储属性和类属性的改变.(对于计算属性不需要定义属性观察者,因为可以在计算属性的set方法中直接观察)
         3.4 怎么监听?   
              通过willSet 和didSet两个方法来监听 , 统称为属性监听器
              

     

    4.类的构造函数
     
         4.1 构造函数类似于OC中的初始化方法: init方法
         4.2 创建一个类,系统会默认提供一个构造函数
     
         4.3 自定义构造函数 , 一般用来初始化时给属性赋值
              注意:如果自定义构造函数,会覆盖系统默认提供的构造函数 , 如果想保留,需要重写
    复制代码
     1  class Person {
     2      var name : String
     3      var age : Int
     4      // 自定义构造函数,会覆盖init()函数
     5      init(name : String, age : Int) {
     6      // 如果在一个方法中, 属性名称产生了歧义(重名), self.不可以省略
     7          self.name = name
     8          self.age = age
     9      }
    10 }
    11 // 创建一个Person对象
    12 let p = Person(name: "why", age: 18)
    13  
    14  
    15 class Person: NSObject {
    16     var name : String
    17     var age : Int
    18     // 重写了NSObject(父类)的构造方法  在init前面加上override
    19     override init() {
    20         name = ""
    21         age = 0
    22     }
    23 }
    24 // 创建一个Person对象
    25 let p = Person()
    复制代码
     
    5.字典转模型
         5.1 使用kvc的条件?
              5.11 必须继承自NSObject
              5.12 在构造函数中使用,必须先调用super.init()
     
         5.2 利用kvc字典转模型非常方便
     
         5.3 使用kvc注意点
              5.31 属性需要有默认的值
              5.32 基本数据类型默认值一般设置为0
              5.33 对象或结构体类型定义为可选类型(可选类型没有赋值前为nil)
    复制代码
     1 class Person: NSObject {
     2     // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值
     3     var name : String?
     4     // 基本数据类型不能是可选类型,否则KVC无法转化
     5     var age : Int = 0
     6     // 自定义构造函数,会覆盖init()函数
     7     init(dict : [String : NSObject]) {
     8         // 必须先初始化对象
     9         super.init()
    10         // 调用对象的KVC方法字典转模型
    11         setValuesForKeysWithDictionary(dict)
    12     }
    13  //如果字典中某些键值对,在类中找不到对应的属性,就会报错
    14     //不想让它报错,可以重写setValue  forUndefinedKey key:
    15     override func setValue(value: AnyObject?, forUndefinedKey key: String) {
    16     }
    17 }
    18 // 创建一个Person对象
    19 let dict = ["name" : "why", "age" : 18]
    20 let p = Person(dict: dict)
    复制代码
     
    6.析构函数
         6.1 swift会自动释放不需要的实例以释放资源
              6.11 swift 通过ARC 处理实例的内存管理
              6.12 当引用计数为0时,系统会自动调用析构函数(不可以手动调用)
              6.13 通常在析构函数中释放一些资源(如:移除通知等操作)
     
         6.2 析构函数的写法
    1 deinit {
    2     // 执行析构过程
    3 }
     
              6.21 示例练习
    复制代码
     1 class Person {
     2     var name : String
     3     var age : Int
     4  
     5     init(name : String, age : Int) {
     6         self.name = name
     7         self.age = age
     8     }
     9  
    10     deinit {
    11         print("Person-deinit")
    12     }
    13 }
    14 
    15 var p : Person? = Person(name: "why", age: 18)
    16 p = nil
    复制代码

     

    前言:swift语法基础篇(二)来了,想学习swift的朋友可以拿去参考哦,有兴趣可以相互探讨,共同学习哦. 
     

     
    一.自动引用计数
     
    1.自动引用计数工作机制
         1.1 swift和oc一样,采用自动引用计数来管理内存
         1.2 当有强引用指向对象,对象的引用计数 +1 , 强引用消失,自动计数 -1
         1.3 如果对象的引用计数为0 , 那么该对象会被销毁
     
    2.循环引用
         2.1 什么是循环引用?
              两个(或多个)对象互相强引用
     
         2.2 循环引用对项目有什么影响
              循环引用会让对象不会被销毁,一直保存在内存中,可能导致项目运行不畅
         
         2.3 怎么解决强引用问题?
              只需要让其中一个对象对另外一个对象的引用变为弱引用即可
              在swift中用waek 相当于OC中的 __weak ,或者使用 unowned 相当于OC中的 __unsafe_unretained
     
    3.weak 和 unowned的区别
         3.1 相同点:
              都是一个弱引用,不会对对象进行retain
         
         3.2 不同点
              3.21 weak(__weak) :当弱引用指向的对象销毁时,该引用会指向nil   所以用weak指向的数据类型为可选类型
              3.22 unowned(__unsafe_unretained) :当弱引用指向的对象销毁时,依然指向原来的内存地址, 容易产生错误(野指针/访问僵尸对象)
              3.23 unowned不支持可选类型
     
    二.可选链
     
    1.什么是可选链?
         简单的说,就是可选类型的对象组成的链条
     
    2.为什么会产生可选链?
         2.1 假设有三个类, 人,狗,玩具   
         2.2 人里面有狗这个属性,狗里面有玩具这个属性, 玩具里面有价格这个属性
         2.3 把玩具这个对象赋值给狗(让狗拥有玩具), 把狗这个对象赋值给人(让人拥有这只狗)
         2.4 想要通过人来修改玩具的价格,就需要 person.dog.toy.price 来修改
         2.5 person.dog这个值得类型是可选类型 ,因为人的狗属性可能为nil   属性,想要使用person.dog ,必须要强制解包
         2.6 person.dog.toy也是可选类型,像这样由可选类型的对象组成的链条就是可选链
         
    3.可选链注意点
         3.1 利用可选链赋值的时候一定要解包
         3.2 利用可选链取值的时候也不要忘记解包
         3.3 利用可选链调用方法的时候 也要先解包
     
    4.利用可选链赋值, 取值,调用方法
         4.1 给可选链赋值:
    复制代码
    1  person.dog!.toy!.price = 50 太危险  强制解包,如果没值,直接程序崩溃
    2  
    3 if let dog = person.dog {
    4     if let toy = dog.toy {
    5         toy.price = 50
    6     }  这样解包虽然安全,但是太麻烦
    7 }
    复制代码
    苹果在swift中推荐使用这种方式来给可选链赋值
    1 person.dog?.toy?.price = 50 
    2 //当person.dog 为nil的时候,后面的操作就不再执行
     
         4.2 从可选链取值: 从可选链中取出的值得类型一定是可选类型 (有可能取不到)
    let price = person.dog?.toy?.price
     
         4.3 可选链调用方法:系统会自动判断可选类型是否有值
    person.dog?.toy?.flying()
     
    三.协议
     
    1.如何定义协议
     
         1.1 swift中协议的方式和类,结构体,枚举相似
    protocol SomeProtocol {
        // 协议方法
    }
     
         1.2 例如:定义一个运动协议
    1 protocol SportProtocol {
    2     func playBasketball()
    3     func playFootball()
    4 }
     
    2.声明一个类,并且遵守协议
         2.1 声明一个基类(不继承其它类),并遵守协议
    复制代码
     1 class SomeClass:FirstProtocol,AnotherProtocol {
     2     // 类的内容
     3     // 实现协议中的方法
     4 }
     5  
     6      例如:
     7 class Person : SportProtocol {
     8     var name : String = ""
     9    
    10     func playBasketball() {
    11         print("打篮球")
    12     }
    13    
    14     func playFootball() {
    15         print("踢足球")
    16     }
    17 }
    复制代码
     
         2.2 类继承自其他类,并遵守协议
    1 class SomeClass:SomeSuperClass, FirstProtocol,AnotherProtocol {
    2     // 类的内容
    3     // 实现协议中的方法
    4 }
     
    3.OC swift不支持多继承, 但是可以通过协议,间接实现多继承
     
    4.协议的继承关系
         4.1 swift中的及协议和OC(NSObject)中的不同 是:NSObjectProtocol
    1 protocol CrazySportProtocol : NSObjectProtocol {
    2     func jumping()
    3 }
     
         4.2 一个协议,可以遵守另一个协议
    1 protocol SportProtocol : CrazySportProtocol {
    2     func playBasketball()
    3 }
         当一个类遵守了这个协议(SportProtocol) 相当于也遵守了CrazySportProtocol 协议, 所以必须实现这两个协议中的方法
     
    5.协议的可选性
     
         5.1 OC中协议可以定义为可选和必选,默认是必选的
         5.2 默认情况下,swift中的协议都是必须实现的 ,否则编译器会报错
         5.3 在swift中如何让协议成为可选的(不用必须实现)
              要在协议前加 @objc ,可以保留OC某些特性,在方法前加optional  该方法就是可选的了
              在实现协议方法时,在方法前面也要加@objc
     
    复制代码
     1 @objc protocol SportProtocol {
     2     func playBasketball()
     3     func playFootball()
     4   //加optional该方法就成为可选的了
     5     optional func jumping()
     6 }
     7  
     8 class Person: SportProtocol {
     9     @objc func playBasketball() {  在方法前也要加上关键字@objc,不管是可选还是必选
    10     } 
    11     @objc func playFootball() {
    12     } 
    13     @objc func jumping() { 
    14     }
    15 }
    复制代码

     

    6.协议在代理模式中的使用
         6.1 一般来说协议都用weak来修饰(弱引用)
         6.2 weak只能用来修饰类
         6.3 在swift中协议既可以被类遵守,也可以被结构体,枚举遵守
     
         
         6.4 如何让协议只能被类准守
              在协议名称后面加上  :class  即可
     
    四.闭包
     
    1.什么是闭包?
         闭包和OC中的block非常相似,一般都用来函数的回调
     
    2.block的回顾
         block作为属性的格式: `@property (nonatomic, strong) void(^finishedCallback)(NSString *)`;
         block作为参数的定义格式:` (void (^)(NSString * str))finishedCallback`
     
    3.闭包的格式:
         (参数列表) -> (返回值类型)
     
    4.闭包的使用

     

    5.尾随闭包
    复制代码
     1  // 尾随闭包 : 如果函数的最后一个参数是一个闭包.那么可以将函数调用写成尾随闭包
     2  //就是把闭包写到()的后面, 本来是写在()里面的
     3  tools?.loadData() { (result) in
     4      print("在ViewController中获取到数据:\(result)")
     5  }
     6        
     7  // 如果函数有且只有一个参数,并且是一个闭包, 那么()也可以省略
     8  tools?.loadData { (result) in
     9      print("在ViewController中获取到数据:\(result)")
    10  }
    复制代码

     

    6.闭包的循环引用
     
         6.1 一般在定义工具类的时候,会在工具类的方法中用到闭包
         6.2 当工具类对闭包有强引用,一个控制器又调用包含该闭包的方法,在闭包方法中使用控制器的属性,就会发生循环引用
         6.3 控制器调用方法,就会对工具类有一个强引用, 闭包又拿到控制器的属性,闭包对象就对控制器有一个强引用
     
         6.4 在内存中就相当于这种表现
              

     

    7.怎么解决闭包的循环引用
     
         与oc中类型,只需要把闭包对控制器的引用改为弱引用
     
    8.怎么改?
     
         当闭包修改控制器的属性时,拿到控制器的属性时,把self(控制器)改成weakself即可
    weak var weakself : ViewController? = self
          
     
    五.swift项目的目录结构简介
     
    1.swift项目目录中没有.h和.m的文件, 只有一个.swift的文件,相当于
    2.swift目录中.swift文件就相当于oc中的.h和.m文件
    3.在swift中,调用项目中的其他源文件不需要导入头文件  (一个 .swift文件就是一个源文件)
     
     
    六.懒加载
     
    1.懒加载的介绍
         1.1 和OC中不同,swift有专门的关键字实现懒加载
         1.2 懒加载本质:当第一次使用时再加载,而且只会被加载一次
         
    2.swift中用lazy关键字来实现懒加载
         2.1 懒加载格式  
    lazy var 变量: 类型 = { 创建变量代码 }()
         = 后面是一个闭包 苹果推荐用闭包来实现懒加载,可在闭包中对变量属性进行初始化
     
         2.2 懒加载的使用
    1 lazy var names : [String] = {
    2   return ["why", "yz", "lmj"]
    3 }()

              当执行到上面代码的时候,names不会被加载到内存中, 当names第一次使用时,才会被加载

              无论names使用多少次,只会被加载一次,也就是说内存中只有一个names属性地址
     
     
    七.swift中的常见注释
     
    1.单行注释
         和OC中的单行注释一样  使用  // 注释内容
     
    2.多行注释
         和OC中的多行注释格式一样   /*  注释内容  */
         不同的是,swift中多行注释可以嵌套使用
     
    3.文档注释
         与oc中不一样  , swift中 用 /// 注释内容  来实现文档注释
     
    4.分组注释
         和oc不一样 oc:  #pragma mark - 注释内容
         swift:  //MARK : - 注释内容
     
    八.访问权限
     
    1.internal :内部的
         1.1 当不指定具体的访问权限时,默认为internal
         1.2 internal的访问权限: 在当前项目(包)的任何地方都能访问
     
    2.private : 私有的
         private的访问权限: 在当前源文件中能够访问    一个 .swift文件就是一个源文件
     
    3.public :公共的
         3.1 public的访问权限 : 可以跨包访问
         3.2 包的概念: 就是一个项目或一个框架   UIKit也是一个框架
     
    九.异常处理
     
    1.在swift中,如果一个方法的最后有一个throws,那么这个方法能抛出异常
         正则表达式就能抛出异常:
         NSRegularExpression(pattern: <#T##String#>, options: <#T##NSRegularExpressionOptions#>)
     
     
    2.如果一个方法抛出异常,必须要对异常进行处理,否则编译报错
     
    3.异常处理的三种方式
         3.1 try : 手动处理异常,可以拿到异常(error)
              要在方法前面加上try   而且外面要用do 包装
        
          //try方式 --> 手动处理异常, 并且可以获取到最终的异常结果
          do {    //如果有异常error有值      
          let regex = try NSRegularExpression(pattern: "", options: .CaseInsensitive)
          } catch {     //通过error拿到异常结果
               print(error)
          }

     

         3.2 try? : 系统处理异常
     
         try?方式 : 如果有异常,则返回nil,如果没有异常,则返回结果   结果(regex)为可选类型
                 let regex = try? NSRegularExpression(pattern: "", options: .CaseInsensitive)
                 regex?.matchesInString("", options: [], range: NSMakeRange(0, 0))
     
         3.3 try! :告诉系统不可能有异常
     
               try!方式(不推荐)  注意:一旦发生异常,程序就会崩溃
                let regex = try! NSRegularExpression(pattern: "", options: .CaseInsensitive)
     
    十.如何抛出异常
    1.在方法参数的后面加上 throws  ,一定要有返回值
     
    2.在某些具体的情况下抛出异常
         比如:传的参数不对等等  ,内部要对参数进行判断
     
    3.抛出的异常,一般定义为枚举类型  枚举后面要跟上 ErrorType 这种类型
     

     

    十一.OC和swift相互调用
     
    1.swift中调用oc
         1.1 创建一个桥接文件 (.h的文件) 文件名一般为 Bridge.h
         1.2 在桥接文件中导入oc的头文件
         1.3 配置桥接文件     工程 —> BuildSetting —> 搜索bridging   在后面写入Bridge.h 的相对路径
     

     

    2.oc中调用swift
         2.1 项目名称要规范 (不能有中文和特殊字符)
         2.2 swift中的类,属性,方法名 前面要加 public
         2.3 在oc文件中导入  工程名-Swift.h  的头文件  工程名-Swift.h  系统会自动生成
     

     

    展开全文
  • 本系列只是一个Swift快速入门的教程,并没有详尽的介绍Swift,Swift也并不是一个简单的编程语言,所以要想详尽的系统学习Swift,本系列并不适合你,此系列只是让开发者可以快速的用Swift来进行开发。另外学习本...

    1. 本系列说明
    本系列只是一个Swift快速入门的教程,并没有详尽的介绍Swift,Swift也并不是一个简单的编程语言,所以要想详尽的系统的学习Swift,本系列并不适合你,此系列只是让开发者可以快速的用Swift来进行开发。另外学习本系列并不需要obj-c的知识,但是如果你想开发iOS,obj-c是必须要学的,因为Swift并不能很快的替代obj-c。另外本系列基于OS X EI Captitan 10.11.2,Xcode7.2。

    2. Swift介绍
    Swift,苹果于2014年WWDC(苹果开发者大会)发布的新开发语言,可与Objective-C共同运行于Mac OS和iOS平台,用于搭建基于苹果平台的应用程序。Swift吸收了众多现代编程语言的优点,尽力的提供简洁的编程语言和强大的功能。

    3. 第一个Swift程序
    Swift源文件的第一行可执行的代码就是Swift的程序的入口:

    print("Hello World")

    Swift程序的执行语句可以无须任何符号作为结束,Swift把每行代码作为了一个语句。但是如果在一行写了多个Swift语句则应该用”;”来作为语句的结束符。

    print("Hello");print("World")

    笔者还是建议用”;”来作为语句的结束符,这样可读性更强。

    3. Playground工具介绍

    Playground是一个简单的测试环境,主要是用于快速测试Swift语法功能和验证API功能,并不是用来进行实际开发应用。如果开发者对Swift语法功能不太确定,则可以用Playground来测试代码,其次Playground也可以用来验证某个函数,类的功能。

    首先我们启动Xcode,选中Playground
    这里写图片描述

    接着在Name文本框输入Playground的名字

    这里写图片描述

    Playground保存成功后就会看到下面的编辑界面,左边是编辑界面,当开发者在左边编写代码,定义变量和常量之后,即可在右边是实时的看到变量或常量的值。我们将上面将的代码写进去就会看到,右边显示”Hello World”说明我们的代码没有问题。下面是运行按钮,点击运行按钮,控制台输出Hello World,第一个Swift程序就完成了。
    这里写图片描述

    4. 用swiftc编译Swift程序
    swiftc的命令基本格式是

     swiftc -o <生成文件> <源程序> 

    我们用文本编辑工具(我用的是Notepad+)在里面写上print(“Hello World”),保存在桌面取名为hello.swift
    打开终端程序,进入桌面目录,输入如下命令:

    swiftc -o hello.out hello.swift

    我们会发现桌面生成了hello.out文件,接下来我们执行命令

    ./hello.out

    这个命令会执行当前目录下的hello.out程序,执行该程序会看到输出Hello World

    上述的编译,运行完整过程:
    这里写图片描述

    本篇先到这里,接下来会讲Swift的基本语法。

    展开全文
  • OpenStack Swift学习笔记

    2014-01-10 10:31:10
    Swift并不是文件系统或者实时的数据存储系统,它是对象存储,用于永久类型的静态数据的长期存储,这些数据可以检索、调整,必要时进行更新。最适合存储的数据类型的例子是虚拟机镜像、图片存储、邮件存储和存档备份...
  • Swift系统

    2015-05-29 09:30:08
    不管怎样,除了官方文档,你可能还需要书,今天介绍三本Swift图书,有了它们你就可以系统全面地学习Swift了。1、《Swift基础教程》 作者:Boisy G. Pitre  译者:袁国忠 书号:978-7-115-39260-2 定价:49.00 元...
  • Swift学习总结

    2018-11-06 09:59:41
    Swift学习 ##1、常量、变量 var / let ####注意一: 在开发中优先使用常量let,只有发现需要修改的情况,才使用变量。 目的: 防止不小心修改的值情况。 ####注意二: 常量的本质: 指向内存地址,不可修改,但是...
  • 构建展示层 本章节主要来完善前前面已经创建好的storyboard中的页面,包括自定义的view等。 1.PKOElementTableViewCell 该自定义view作为列表的行view,包含...这里要注意需要通过setNeedsDisplay告诉系统进行绘制。
  • Swift学习软件推荐

    2019-04-12 08:54:43
    Swift学习软件推荐 这里给大家推荐一款Swift编程语言的学习软件——编程雨燕。我们先来看一下软件的内容: 整个软件轻便简洁,软件的内容为Apple的Swift编程语言。整体的内容上分为不同的学习专栏,让我们可以...
  • 对象存储和文件系统存储区别: 所谓文件系统的本质是POSIX接口,“对象”这个名词是做对象存储的人为了把自己做的东西和文件系统区分开而用的术语,把存在对象存储里的文件叫做“对象”,所以选择文件系统还是对象...
  • Swift中的Function

    2015-12-15 17:34:49
    概述:在刚学习Swift的时候,我都是盲目的找资料,这里找一点那里找一点,没有统一的学习资料。正好这段时间公司没有什么事情做,领导又让我学习一下Swift编程,索性我就跟着Apple官方的推荐的《The Swift ...
  • 如今人们使用的各式各样的智能手机系统都是不一样的,比如iphone系统就是有Swift语言编写而成的,我们可以在Swift语法当中看到Objective—C、JavaScript、C#、Python等语言的影子,它借鉴了这些语言的影子,具有编译...
  • 学习swift《创建简单的控件》  闲来无事无事于是就学学swift,我先前学的是oc,于是昨天看了一天的swift的语法和结构。以前也看过swift只是没有系统的学过。发现swift和oc语法差别很大,不过看完...
  • Swift】架构学习

    2017-07-14 19:28:26
    Swift采用层次数据模型,共3层逻辑结构:Account/Container/Object Account等同于租户,可以拥有多个Container;Container是object的父容器,可理解为目录或者文件夹,当然Container不支持嵌套;Object就是实际存储...
  • 对象存储系统Swift技术详解:综述与概念  OpenStack Object Storage (Swift) 是用来创建冗余的、可扩展的对象存储(引擎)的开源软件。通过阅读Swift的技术文档,我们可以理解其中的设计的原理和实现的方法 
  • 我们将介绍Swift的基础知识,并学习如何使用该语言构建你的第一个数据科学模型 介绍 Python被广泛认为是数据科学中最好、最有效的语言。近年来我遇到的大多数调查都将Python列为这个领域的领导者。 但事实是数据...
  • Swift是一款易学易用的编程语言,而且它还是第一套具有与脚本语言同样的表现力和趣味性的系统编程语言。Swift的设计以安全为出发点,以避免各种常见的编程错误类别。 2015年12月4日,苹果公司宣布其Swift编程语言...
  • 文章转载自我的个人博客原文链接自言自语: 亿万千百十, 皆起于一资料1 —...Github上的地址点我Using Swift with Cocoa and Objective-CWWDC 2015 系统化的开发文档iOS Developer LibrarySwift 开源及跨平台开发swift
  • 之前学习了android,虽然不是很精通,不过基本应用都还可以写出来,fuhome未来之家控制设备的app已经发布4.3版本了,bug也相对减少了许多,那就开始IOS苹果的app开发学习。   首先,买了一台MAC mini,才开始很不...
1 2 3 4 5 ... 20
收藏数 17,109
精华内容 6,843
热门标签