iOS - Swift Array 数组

简介: 前言 public struct Array : CollectionType, MutableCollectionType, _DestructorSafeContainer public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration在 Swift 语言中,数据在被存储进某个数组之前,类型必须明确,且与数组其他元素类型相同。

前言

    public struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer
    public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration
  • 在 Swift 语言中,数据在被存储进某个数组之前,类型必须明确,且与数组其他元素类型相同。在 Swift 语言中的数组和 C 语言中的不同,Swift 语言中的数组是值类型的,不管是赋值还是当作参数传递,都只是维护他的拷贝。你可以放心的操作他的拷贝,因为你做的任何操作都不会反馈回它本身,这是值类型自身的规则。

1、Array 与 NSArray 的相互转换

  • Array 与 NSArray 之间可以相互转换。Array 转成 NSArray 时,数组中的各项元素被转换为 AnyObject 类型。NSArray 转换成 Array 时,数组中的各项元素也被转换为 AnyObject 类型。
    // Array 转 NSArray
    
        // Array 转换成 NSArray<AnyObject> 型
        let nsArray1:NSArray = array
    
        // Array 转换成 NSArray<AnyObject> 型
        let nsArray2:NSArray = array as NSArray
        
    // NSArray 转 Array
    
        // NSArray 转换成 Array<AnyObject> 型
        let swiftArray1:Array = nsArray1 as Array
    
        // NSArray 转换成 Array<AnyObject> 型
        let swiftArray2:Array = nsArray1 as [AnyObject]
    
        // NSArray 转换成 Array<Int> 型
        let swiftArray3:Array = nsArray1 as! [Int]

2、数组的 创建

    // Array 型数组
            
        // 不赋初值,指定数组内数据为 String 型
        let array1 = [String]()
        
        // 不赋初值,Array<String> 等价于 [String]
        let array2 = Array<String>()
        
        // 不指定数组内数据类型,自动推断
        let array3:Array = ["bei", "jing"]
        
        // 指定数组内数据类型为 String 型
        let array4:Array<String> = ["huan", "ying", "ni"]
        
        // 不指定数组内数据类型,自动推断
        let array5 = ["bei", "jing", "huan", "ying", "ni"]
        
        // 指定数组内数据类型为 Int 型
        let array6:[Int] = [1, 2, 3, 4, 5, 6]
        
        // 指定数组内数据类型为 AnyObject 型
        let array7:[AnyObject] = [1, 2, 3, 4, 5, 6, "happy"]
        
        // 创建二维数组
        let array8:Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
        
    // NSArray 型数组
            
        let swiftArray:Array = ["bei", "jing", "nin", "hao"]
            
        let nsArray1:NSArray = swiftArray
        let nsArray2:NSArray = swiftArray as NSArray
            
        let nsArray3 = NSArray()
            
        // array: [AnyObject]
        let nsArray4 = NSArray(array: array7)
        
        // array: [AnyObject]
        let nsArray6 = NSArray(array: ["bei", "jing", "huan", "ying", "ni"])
        
        // array: NSArray
        let nsArray5 = NSArray(array: nsArray2)
        
        // object: AnyObject
        let nsArray7 = NSArray(object: "qian")
        
        // objects: AnyObject...
        let nsArray8 = NSArray(objects: "bei", "jing", "huan", "ying", "ni")
        
        // 从 文件 创建字符串
        let nsArray9:NSArray? = NSArray(contentsOfFile: NSHomeDirectory() + "/Desktop/test.txt")
        
        // 从 Url 创建字符串
        let nsArray10:NSArray? = NSArray(contentsOfURL: NSURL(fileURLWithPath: NSHomeDirectory() + "/Desktop/test.txt"))

3、数组的 长度计算

    // Array 或 NSArray 型数组
    
        let array = ["bei", "jing", "huan", "ying", "ni"]
            
        let num:Int = array.count

4、数组位置的 获取

    // Array 型字符串
            
        let array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取起始位置,即 0
        let startIndex = array.startIndex
        
        // 获取结束位置,指 数组最后一个元素的位置
        let endIndex = array.endIndex
        
        // 获取指定位置下标值
        let index = array.startIndex.advancedBy(2)
        
        // 获取下标区间值
        let range = array.startIndex.advancedBy(4)...array.startIndex.advancedBy(6)
        
        // 获取指定位置下标的 前一个值
        let predecessorIndex = array.startIndex.advancedBy(2).predecessor()
        
        // 获取指定位置下标的 后一个值
        let successorIndex = array.startIndex.advancedBy(2).successor()

5、数组元素的 获取

    // Array 型数组
            
        let array:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取数组指定下标的元素
        let obj1:String = array[1]
        
        // 获取数组的第一个元素
        let obj2:String? = array.first
        
        // 获取数组的最后一个元素
        let obj3:String? = array.last
        
        // 获取数组指定范围内的元素
        let obj4 = array[2...4]

    // NSArray 型数组
            
        let nsArray:NSArray = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取指定下标元素,NSArray 中数据类型为 AnyObject
        let obj5:String = nsArray[2] as! String
        
        // 获取数组指定下标的元素
        let obj6:String = nsArray.objectAtIndex(2) as! String
        
        // 获取数组的第一个元素
        let obj7:String = nsArray.firstObject as! String
        
        // 获取数组的最后一个元素
        let obj8:String = nsArray.lastObject as! String
        
        // 获取数组指定范围内的元素
        let obj9 = nsArray.objectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 2)))
        
        // 获取数组指定范围内的元素
        let obj10 = nsArray.subarrayWithRange(NSMakeRange(2, 3))

6、数组下标的 获取

    // Array 型数组
            
        let array:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取指定元素的下标,若元素不存在,返回 nil
        let indexNum1:Int? = array.indexOf("huan")
            
    // NSArray 型数组
            
        let nsArray:NSArray = ["bei", "jing", "huan", "ying", "ni"]
            
        // 获取指定元素的下标,若元素不存在,返回 Int.max
        let indexNum2:Int = nsArray.indexOfObject("hun")

7、数组的 判断

    // Array 型数组
            
        let arr1:Array = [1, 3, 5, 8]
        let arr2:Array = [1, 3, 7, 8]
            
        // 判断两个数组是否相等
        let bl1:Bool = arr1 == arr2
        
        // 判断数组是否为空
        let bl2:Bool = arr1.isEmpty
        
        // 判断数组中是否存在指定的元素
        let bl3:Bool = arr1.contains(55)
            
    // NSArray 型数组
            
        let nsArr1:NSArray = [2, 3, 5, 8]
        let nsArr2:NSArray = [1, 4, 7, 9]
            
        // 判断两个数组是否相等
        let bl4:Bool = nsArr1.isEqualToArray(nsArr2 as [AnyObject])
        
        // 判断数组中是否存在指定的元素
        let bl5:Bool = nsArr1.containsObject(7)
        
        // 返回两个数组中第一个相同的元素,没有时返回 nil
        let firstObj:AnyObject? = nsArr1.firstObjectCommonWithArray(nsArr2 as [AnyObject])

8、数组元素的组合

    // NSArray 型数组
            
        let arr1:NSArray = ["bei", "jing", "huan", "ying", "nin"]
        let arr2:NSArray = ["Users", "JHQ0228", "Desktop"]
            
        // 按指定字符组合
        let str1:String = arr1.componentsJoinedByString(" ")
        
        // 按路径组合
        let str2:String = NSString.pathWithComponents(arr2 as! [String])

9、数组元素的 追加

    // Array 型数组
            
        var arr1:Array = ["bei", "jing"]
            
        // 使用 "+" 号连接两个数组
        let arr2 = arr1 + ["huan", "ying", "ni"]
        
        // 在数组末尾追加一个元素
        arr1.append("hao")
        
        // 在指定位置插入一个元素
        arr1.insert("ni", atIndex: 2)
            
    // NSArray 型数组
            
        let nsArray:NSMutableArray = ["jing", "huan"]
            
        // 向数组添加一个元素,返回一个新的数组
        let nsArray1 = nsArray.arrayByAddingObject("ma")
        
        // 在数组末尾追加一个元素
        nsArray.addObject("ni")
        
        // 在数组末尾追加一个数组
        nsArray.addObjectsFromArray(["ni", "hao"])
        
        // 在指定位置追加一个元素
        nsArray.insertObject("bei", atIndex: 0)

10、数组元素的 删除

    // Array 型数组
            
        var arr1:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        // 删除指定位置的数组元素
        arr1.removeAtIndex(3)
        
        // 删除数组中的最后一个元素
        arr1.removeLast()
        
        // 删除指定范围内的数组元素
        arr1.removeRange(0...1)
        
        // 删除所有数组元素
        arr1.removeAll(keepCapacity: true)
            
    // NSArray 型数组
            
        let nsArr1:NSMutableArray = ["nan", "jing", "huan", "ying", "nin", "bei", "jing", "ni", "hao"]
            
        // 删除指定下标的元素
        nsArr1.removeObjectAtIndex(2)
        
        // 删除指定元素,删除所有指定元素
        nsArr1.removeObject("ying")
        
        // 删除指定元素
        nsArr1.removeObjectIdenticalTo("nan")
        
        // 删除最后一个元素
        nsArr1.removeLastObject()
        
        // 删除指定范围的元素
        nsArr1.removeObjectsInRange(NSMakeRange(2, 1))
        
        // 删除所有元素
        nsArr1.removeAllObjects()

11、数组元素的 替换

    // NSArray 型数组
            
        let nsArr:NSMutableArray = ["nan", "jing", "huan", "ying", "nin"]
            
        // 替换指定下标元素
        nsArr.replaceObjectAtIndex(0, withObject: "bei")
        
        // 替换的元素个数与被替换的元素个数需相等
        nsArr.replaceObjectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(2, 3)), 
                          withObjects: ["ni", "hao", "ma"])
        
        // 用数组替换
        nsArr.replaceObjectsInRange(NSMakeRange(2, 3), withObjectsFromArray: ["huan", "ying"])
            
        nsArr.replaceObjectsInRange(NSMakeRange(0, 2), 
               withObjectsFromArray: ["huan", "ying", "nin", "nan", "jing", "huan"], 
                              range: NSMakeRange(3, 2))

12、数组元素的 交换

    // NSArray 型数组
    let nsArr:NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]
        
    nsArr.exchangeObjectAtIndex(2, withObjectAtIndex: 4)

13、数组元素的 修改

    // Array 型数组
        
        var arr:Array = ["bei", "jing", "huan", "ying", "ni"]
            
        arr[0] = "nan"
            
        // NSArray 型数组
        let nsArr:NSMutableArray = ["bei", "jing", "huan", "ying", "nin"]
            
        // 修改数组中的某个元素
        nsArr[4] = "ni"
        
        // 修改整个数组(覆盖重写)
        nsArr.setArray(["ni", "hao"])

14、数组元素的 过滤

    // Array 型数组
            
        let arr:Array = [1, 9, 2, 8, 45]
            
        let array:[Int] = arr.filter { (obj:Int) -> Bool in
            
            // 过滤掉不能被 3 整除的数
            return obj % 3 == 0
        }
            
    // NSArray 型数组
            
        let nsArr:NSMutableArray = [1, 9, 2, 8, 45]
            
        let nsArray:[AnyObject] = nsArr.filter { (obj:AnyObject) -> Bool in
            
            // 过滤掉不能被 3 整除的数
            return (obj as! Int) % 3 == 0
        }

15、数组的遍历

  • 用 for...in 循环遍历

        // Array 或 NSArray 型数组
    
            let arr = ["bei", "jing", "huan", "ying", "ni"]
    
            // tmp 无需定义,在 Swift 2.2 中 C 语言样式的 for 循环语句被废弃
            for tmp in arr {
    
                print(tmp)
            }
  • 用闭包循环遍历

        // NSArray 型数组
    
            let arr:NSArray = ["bei", "jing", "huan", "ying", "ni"]
    
            arr.enumerateObjectsUsingBlock { (obj:AnyObject, idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in
    
                print(obj)
    
                if obj.isEqualTo("huan") {
    
                    // 停止继续遍历
                    stop.initialize(true)
                }
            }
  • 用迭代器遍历

        // NSArray 型数组
    
            let arr:NSArray = ["bei", "jing", "huan", "ying", "ni"]
    
            // 正序遍历
            let enu1:NSEnumerator = arr.objectEnumerator()
    
            // 反序遍历
            let enu2:NSEnumerator = arr.reverseObjectEnumerator()
    
            // AnyObject 后不要加 ?,否则会导致一直循环
            while let obj:AnyObject = enu1.nextObject() {
    
                print(obj)
            }
  • 条件遍历

        // NSArray 型数组
    
            let arr:NSArray = ["bei", "jing", "huan", "ying", "huan", "ni"]
    
            // 1. indexesOfObjectsPassingTest 找出数组中所有满足条件的值
    
                let indexSet:NSIndexSet = arr.indexesOfObjectsPassingTest { (obj:AnyObject, 
                                                                             idx:Int, 
                                                                            stop:UnsafeMutablePointer<ObjCBool>) -> Bool in
    
                    // 条件满足时返回满足的数组元素的下标
                    return obj.isEqualTo("huan") ? true : false
                }
    
                indexSet.enumerateIndexesUsingBlock { (idx:Int, stop:UnsafeMutablePointer<ObjCBool>) in
    
                    print(idx)
                }
    
            // 2. indexOfObjectPassingTest 找出数组中第一个满足条件的值
    
                let index:Int = arr.indexOfObjectPassingTest { (obj:AnyObject, 
                                                                idx:Int, 
                                                               stop:UnsafeMutablePointer<ObjCBool>) -> Bool in
    
                    // 条件满足时返回满足的数组元素的下标
                    return obj.isEqualTo("huan") ? true : false
                }
    
                print(index)

16、数组的排序

  • 冒泡排序

        // NSArray 型数组
    
            let array:NSMutableArray = ["bei", "jing", "huan", "ying", "ni"]
    
            for i in 0 ..< array.count - 1 {
                for j in 0 ..< array.count - 1 - i {
    
                    // 大小判断 升序
                    if (array[j] as! String).compare(array[j + 1] as! String) == NSComparisonResult.OrderedAscending {
    
                        // 位置交换
                        array.exchangeObjectAtIndex(j, withObjectAtIndex: j + 1)
                    }
                }
            }
            print(array)
  • 用闭包排序

        // Array 型数组
    
            // 1. 利用闭包进行排序,可变数组排序
    
                var varArray:Array = ["sunday", "sunny", "summer", "sun"];
    
                varArray.sortInPlace { (obj1:String, obj2:String) -> Bool in
    
                    return obj1 < obj2
                }
    
                print(varArray)
    
            // 2. 利用闭包进行排序,不可变数组排序
    
                let letArray:Array = ["sunday", "sunny", "summer", "sun"];
    
                let array = letArray.sort { (obj1:String, obj2:String) -> Bool in
    
                    return obj1 < obj2
                }
    
                print(array)
    
        // NSArray 型数组
    
            // 1. 利用闭包进行排序,可变数组排序
    
                let nsMArray1:NSMutableArray = ["sunday", "sunny", "summer", "sun"];
    
                nsMArray1.sortUsingComparator { (obj1:AnyObject, obj2:AnyObject) -> NSComparisonResult in
    
                    let result:NSComparisonResult = (obj1 as! String).compare(obj2 as! String)
    
                    return result
                }
    
                print(nsMArray1)
    
            // 2. 利用闭包进行排序,不可变数组排序
    
                let nsArray1:NSArray = ["sunday", "sunny", "summer", "sun"];
    
                let array1:NSArray = nsArray1.sortedArrayUsingComparator { (obj1:AnyObject, 
                                                                            obj2:AnyObject) -> NSComparisonResult in
    
                    let result:NSComparisonResult = (obj1 as! String).compare(obj2 as! String)
    
                    return result
                }
    
                print(array1)
  • 用指定的方法排序

        // Array 型数组
    
            // 1. 用指定的方法排序,可变数组排序
    
                var varArray:Array = ["sunday", "sunny", "summer", "sun"];
    
                // 直接使用 Swift 数组类型中定义的小于号 (<) 实现,public func <(lhs: String, rhs: String) -> Bool
                varArray.sortInPlace( < )
    
                print(varArray)
    
            // 2. 用指定的方法排序,不可变数组排序
    
                let letArray:Array = ["sunday", "sunny", "summer", "sun"];
    
                // 直接使用 Swift 数组类型中定义的小于号 (<) 实现,public func <(lhs: String, rhs: String) -> Bool
                let array = letArray.sort( < )
    
                print(array)
    
        // NSArray 型数组
    
            // 1. 用指定的方法排序,可变数组排序
    
                let nsMArray1:NSMutableArray = ["sunday", "sunny", "summer", "sun"];
    
                // 原数组的顺序改变,指定元素的比较方法:compare:,默认为升序排列,
                // #selector(NSNumber.compare(_:)) 代替 Selector("compare:")
                nsMArray1.sortUsingSelector(#selector(NSNumber.compare(_:)))
    
                print(nsMArray1)
    
                // 使排序结果 降序 排列
                let enu:NSEnumerator = nsMArray1.reverseObjectEnumerator()
    
                while let obj:AnyObject = enu.nextObject() {
                    print(obj)
                }
    
            // 2. 用指定的方法排序,不可变数组排序
    
                let nsArray1:NSArray = ["sunday", "sunny", "summer", "sun"];
    
                // 返回一个排好的数组,原数组的顺序不变,指定元素的比较方法:compare:
                let array1:NSArray = nsArray1.sortedArrayUsingSelector(#selector(NSNumber.compare(_:)))
    
                print(array1)
    
            // 3. 用指定的方法排序,自定义类
    
                // Student.swift
    
                    class Student: NSObject {
    
                        var firstName:String
                        var lastName:String
    
                        init(firstName:String, lastName:String ) {
    
                            self.firstName = firstName
                            self.lastName = lastName
                        }
    
                        func compareStudent(stu:Student) -> NSComparisonResult {
    
                            // 先按照姓排序
                            var result:NSComparisonResult = self.lastName.compare(stu.lastName)
    
                            if result == NSComparisonResult.OrderedSame {
    
                                // 如果有相同的姓,就比较名字
                                result = self.firstName.compare(stu.firstName)
                            }
                            return result;
                        }
    
                        // 需遵守协议 Printable
                        override var description: String{
    
                            return String(format: "%@, %@", self.lastName, self.firstName)
                        }
                    }
    
                // main.swift
    
                    let stu1:Student = Student(firstName: "MingJie", lastName: "Li")
                    let stu2:Student = Student(firstName: "LongHu", lastName: "Huang")
                    let stu3:Student = Student(firstName: "LianJie", lastName: "Li")
                    let stu4:Student = Student(firstName: "Jian", lastName: "Xiao")
    
                    // 用指定的方法排序,可变数组排序
    
                        let nsMArray2:NSMutableArray = NSMutableArray(objects: stu1, stu2, stu3, stu4)
    
                        // 代替 Selector("compareStudent:")
                        nsMArray2.sortUsingSelector(#selector(Student.compareStudent(_:)))
    
                        print(nsMArray2)
    
                    // 用指定的方法排序,不可变数组排序
    
                        let nsArray2:NSArray = NSArray(objects: stu1, stu2, stu3, stu4)
    
                        let array2:NSArray = nsArray2.sortedArrayUsingSelector(#selector(Student.compareStudent(_:)))
    
                        print(array2)
  • 按描述器排序

        // Student.swift
    
            class Student: NSObject, Printable {
    
                var firstName:String
                var lastName:String
    
                init(firstName:String, lastName:String ) {
    
                    self.firstName = firstName
                    self.lastName = lastName
                }
    
                override var description: String{
    
                    return String(format: "%@, %@", self.lastName, self.firstName)
                }
            }
    
        // main.swift
    
            let stu1:Student = Student(firstName: "MingJie", lastName: "Li")
            let stu2:Student = Student(firstName: "LongHu", lastName: "Huang")
            let stu3:Student = Student(firstName: "LianJie", lastName: "Li")
            let stu4:Student = Student(firstName: "Jian", lastName: "Xiao")
    
            // 先按照姓进行排序
            let lastnNmeDesc:NSSortDescriptor = NSSortDescriptor(key: "lastName", ascending: true)
    
            // 再按照名进行排序
            let firstNameDesc:NSSortDescriptor = NSSortDescriptor(key: "firstName", ascending: true)
    
            // 1.按描述器排序,可变数组排序
    
                let array1 = NSMutableArray(objects: stu1, stu2, stu3, stu4)
    
                // 按顺序添加排序描
                let descs1 = NSArray(objects: lastnNmeDesc, firstNameDesc)
    
                array1.sortUsingDescriptors(descs1 as! [NSSortDescriptor])
    
                print(array1)
    
            // 2.按描述器排序,不可变数组排序
    
                let array2 = NSArray(objects: stu1, stu2, stu3, stu4)
    
                // 按顺序添加排序描
                let descs2 = NSArray(objects: lastnNmeDesc, firstNameDesc)
    
                let array3 = array2.sortedArrayUsingDescriptors(descs2 as! [NSSortDescriptor])
    
                print(array3)
目录
相关文章
|
7天前
|
存储 Go 索引
go语言中的数组(Array)
go语言中的数组(Array)
92 67
|
4月前
|
Swift iOS开发
iOS Swift使用Alamofire请求本地服务器报错-1002
iOS Swift使用Alamofire请求本地服务器报错-1002
114 1
|
21天前
|
安全 Swift iOS开发
Swift 与 UIKit 在 iOS 应用界面开发中的关键技术和实践方法
本文深入探讨了 Swift 与 UIKit 在 iOS 应用界面开发中的关键技术和实践方法。Swift 以其简洁、高效和类型安全的特点,结合 UIKit 丰富的组件和功能,为开发者提供了强大的工具。文章从 Swift 的语法优势、类型安全、编程模型以及与 UIKit 的集成,到 UIKit 的主要组件和功能,再到构建界面的实践技巧和实际案例分析,全面介绍了如何利用这些技术创建高质量的用户界面。
24 2
|
28天前
|
安全 数据处理 Swift
深入探索iOS开发中的Swift语言特性
本文旨在为开发者提供对Swift语言在iOS平台开发的深度理解,涵盖从基础语法到高级特性的全面分析。通过具体案例和代码示例,揭示Swift如何简化编程过程、提高代码效率,并促进iOS应用的创新。文章不仅适合初学者作为入门指南,也适合有经验的开发者深化对Swift语言的认识。
45 9
|
1月前
|
存储 Swift iOS开发
Swift 数组
10月更文挑战第27天
23 3
|
1月前
|
Swift iOS开发 UED
如何使用Swift和UIKit在iOS应用中实现自定义按钮动画
本文通过一个具体案例,介绍如何使用Swift和UIKit在iOS应用中实现自定义按钮动画。当用户点击按钮时,按钮将从圆形变为椭圆形,颜色从蓝色渐变到绿色;释放按钮时,动画以相反方式恢复。通过UIView的动画方法和弹簧动画效果,实现平滑自然的过渡。
55 1
|
1月前
|
安全 API Swift
探索iOS开发中的Swift语言之美
【10月更文挑战第23天】在数字时代的浪潮中,iOS开发如同一艘航船,而Swift语言则是推动这艘船前进的风帆。本文将带你领略Swift的独特魅力,从语法到设计哲学,再到实际应用案例,我们将一步步深入这个现代编程语言的世界。你将发现,Swift不仅仅是一种编程语言,它是苹果生态系统中的一个创新工具,它让iOS开发变得更加高效、安全和有趣。让我们一起启航,探索Swift的奥秘,感受编程的乐趣。
|
2月前
|
Swift iOS开发 UED
如何使用Swift和UIKit在iOS应用中实现自定义按钮动画
【10月更文挑战第18天】本文通过一个具体案例,介绍如何使用Swift和UIKit在iOS应用中实现自定义按钮动画。当用户按下按钮时,按钮将从圆形变为椭圆形并从蓝色渐变为绿色;释放按钮时,动画恢复原状。通过UIView的动画方法和弹簧动画效果,实现平滑自然的动画过渡。
55 5
|
2月前
|
人工智能 前端开发 JavaScript
拿下奇怪的前端报错(一):报错信息是一个看不懂的数字数组Buffer(475) [Uint8Array],让AI大模型帮忙解析
本文介绍了前端开发中遇到的奇怪报错问题,特别是当错误信息不明确时的处理方法。作者分享了自己通过还原代码、试错等方式解决问题的经验,并以一个Vue3+TypeScript项目的构建失败为例,详细解析了如何从错误信息中定位问题,最终通过解读错误信息中的ASCII码找到了具体的错误文件。文章强调了基础知识的重要性,并鼓励读者遇到类似问题时不要慌张,耐心分析。
|
2月前
|
存储 Java
Java“(array) <X> Not Initialized” (数组未初始化)错误解决
在Java中,遇到“(array) &lt;X&gt; Not Initialized”(数组未初始化)错误时,表示数组变量已被声明但尚未初始化。解决方法是在使用数组之前,通过指定数组的大小和类型来初始化数组,例如:`int[] arr = new int[5];` 或 `String[] strArr = new String[10];`。
90 2